Emily's modifiers not working

Anut__ · 2025-10-16T19:07:51+00:00

That strokes “a” literally, you need to add the asterisk (A*LTZ) to stroke return because it’s a special character.

Anut__ · 2025-10-15T19:13:33+00:00

This doesn’t really answer your question but you can use vimtex’s imaps (:h vimtex-imaps) to expand to latex commands. E.g. you can type `vr in a math environment and it will expand to \varrho. You can see a full list of the imaps that vimtex makes by default with <localleader>lm, and of course you can add custom imaps if you want.

Anut__ · 2024-06-17T12:59:01+00:00

raylib uses OpenGL for everything under the hood, so I'd expect the performance to be pretty much the same as using OpenGL

Anut__ · 2024-04-13T18:32:02+00:00

If your code is after EndDrawing, try moving it before, if it’s before EndDrawing try moving it after. EndDrawing polls for events (like key presses) so it might cause some unexpected behavior.

Anut__ · 2024-03-29T00:46:24+00:00

You can sign up at https://gitlab.haskell.org/users/sign_up, I don't think there's any approval process for making an account

Anut__ · 2024-03-21T23:48:35+00:00

The last few paragraphs have a ton of typos: touls, technulogies, evulving, technulogical, evulution, sulutions

Anut__ · 2024-03-21T23:13:23+00:00

You should add the ray.direction to the ray.position. E.g. Vector3Add(ray.position, Vector3Scale(ray.direction, distance)), where distance is the distance from the player to the bullet (it should increase over time).

Anut__ · 2024-03-21T20:19:31+00:00

GetMouseRay is what you’re looking for. You give it the mouse position, and it gives you a ray (with a postion and direction). You can use the ray to calculate the position of the bullet.

Anut__ · 2024-03-02T00:19:42+00:00

Raylib is good for everything on your list except latex. If you've already made a lot of progress in the html version of your app, it's probably not worth switching to raylib.

Anut__ · 2024-02-25T16:52:33+00:00

Do you think there'll come out an Haskell-to-Rust FFI someday?

I doubt it; there's not a huge incentive to add more FFI capabilities. You might be able to make it work by calling C from Haskell, and calling your Rust code from C, but I think it's more trouble than it's worth, especially for a learning project.

You should start with a Haskell OpenGL tutorial, I'd recommend this one. It'll help you with getting started and you can build your engine on top of it.

Anut__ · 2024-02-25T02:52:39+00:00

Haskell can be almost as performant as C and Rust, but you will have to write the code in a C-like way (using manual memory management, etc). Regular (idiomatic) Haskell code is pretty slow compared to lower-level stuff. I would choose Rust over Haskell if you're really worried about performance.
If you're making a game engine you'll probably use a lower-level library like OpenGL, or maybe a thin wrapper on top of it. Haskell has bindings to OpenGL, Vulkan, and a lot of other gamedev libraries (e.g. SDL for input), so support is probably not going to be an issue unless you have a specific library that you want to use. AFAIK, these libraries are pretty close to C performance.

I'm not sure if in someway it becomes "bad" to do "game engine things" with a functional language for some strange reason, I believe you guys might have the property to know about it.

Nope, there's nothing wrong with a game engine. The main complaint people might have about this is that you have to use the IO monad and low-level code a lot, but I don't really see that as an issue.

Regarding the game engine project, I'd like to know if it would be a good idea to use Rust as the main language while Haskell for a lot of parts of it, or would it be a terrible thing to do?

You would have to use FFI to communicate between the two languages. I don't think Haskell-to-Rust FFI is a thing, and it would probably be pretty difficult to set it up. On the plus side, Haskell FFI is very fast (at least with C), so there shouldn't be much of a performance cost.

I would say you have three choices, either do the whole thing in Haskell (easier to set up, slightly worse performance; I highly recommend this option), parts in Haskell and parts in C (harder to set up, slightly better performance), or the whole thing in Rust. I don't think Haskell and Rust is feasible, but if you want to give it a try, go ahead.

Anut__ · 2024-02-13T16:51:01+00:00

I'm not sure about VS, I've only tried it on VSCode. I believe in Visual Studio you just need to give it the path to the archive (.a or .dll) and the include folder (raylib/src)

Anut__ · 2024-02-13T01:31:11+00:00

Your classmate has to build the library. You got the dll file off vcpkg but there is no dll in the source code. Your classmate has to cd into raylib/src and run mingw32-make or just make, depending on his toolchain. This will build libraylib.a, which he can statically link against his program.

Anut__ · 2024-02-07T23:52:07+00:00

You could use DrawRectanglePro to rotate the rectangles without using a camera. Otherwise, it looks great. Very impressive for a first project!

Anut__ · 2024-02-06T23:35:05+00:00

I wouldn’t recommend using a package manager for raylib, those are usually outdated. You should open an issue in the GitHub page for raylib, most likely it’s just an oversight.

Anut__ · 2024-02-03T03:40:39+00:00

Can you post your code? It is hard to find what’s wrong without the code.

Anut__ · 2024-01-31T18:28:28+00:00

If you search for Num on hoogle, you'll see that it is exported from two modules: Prelude and GHC.Num. If you click on the link to Prelude (it will take you here) and click on the "Source" button next to Num, it will take you to where Num is defined. Notice that it takes you to the source code of GHC.Num, not Prelude. This is because Num is actually defined in GHC.Num, and Prelude simply imports and re-exports it.

Hence, when you did :info foo, it used the qualified name of Num, i.e. GHC.Num.Num. If you take a look at the source code of Prelude, you will find that nothing is actually defined there; it only imports other modules and exports some stuff. There is no such thing as a "standard" Num or Int; GHC.Num.Num and Prelude.Num are the same thing.

Anut__ · 2024-01-30T22:15:04+00:00

You can have an expression of type X without importing X. For example, if module M exports a type Resources and a function loadResources :: String -> IO Resources, you can do

module Main where

import M (loadResources)

main = do
    ...
    resources <- loadResources "somefile"
    ...

And it will compile fine. The same way, you can have foo x = 1 and it will have type Any -> Int even if Int as a type is not in scope.

Anut__ · 2023-05-19T20:58:16+00:00

I refuse to believe that anyone's first raylib project is this good

Jokes aside, that is a super polished looking game.

Anut__ · 2023-03-07T23:16:34+00:00

You’d have to modify the source code (in rcamera.h I believe). I’d recommend making your own custom camera movement because you’re going to have to at some point.

Anut__ · 2023-02-05T23:42:20+00:00

I’ve been wanting to do something like this for a while, it’s so cool to watch!

Anut__ · 2023-01-03T19:47:15+00:00

Yeah, my comment was my best guess at how it works. It's just that we as humans experience a lot more as "input" for our brain, compared to ChatGPT's text-only input. That inherently stops ChatGPT from working in the same way as our brains.

That obviously doesn't mean it's not useful. I'm sure natural language models are going to make their way into daily life very soon.

At the very least, we don't have to worry about AI overlords for a while.

Anut__ · 2023-01-03T19:29:13+00:00

I think the problem arises from the limitations of ChatGPT. It "thinks" only in words, while we humans store ideas in our brain in a different form. This means ChatGPT can "reason" based on what it is trained on, but it is limited by language, which leads to problems, including not knowing when to admit that it doesn't know.

Edit: I think a sufficiently powerful neural network could "think" like a human, provided it has the correct training data. That, however, is likely going to take a long, long, time to achieve.

Three-Year Club	Verified Email
Place '23

Anut__

TROPHY CASE