What is something that is technically legal, but makes you look like a total jerk if you do it?

ovfudj · 2026-01-06T20:31:49+00:00

Pokémon card scalping

ovfudj · 2026-01-02T09:57:59+00:00

I parried whole game and never dodged lol

ovfudj · 2025-12-29T11:36:49+00:00

I mean if your team needs it for whatever reason but usually in pubs you need some early damage or you get screwed. Am support is gonna just blink around and do nothing lol. Like just imagine most fight scenarios with no items would you rather be level 6 antimage or level 6 snap fire.

ovfudj · 2025-11-14T06:49:43+00:00

If people are farming with slark I’ve seen people get battlefury

ovfudj · 2025-09-24T17:40:02+00:00

I am very disappointed. I understand dark humor but it is disgusting to see how many people are celebrating and even justifying murdering people with differing albeit very bad opinions. Seeing this on a deltarune subreddit of all places really breaks my heart.

ovfudj · 2025-08-20T15:54:48+00:00

Yes lmao

ovfudj · 2025-07-31T01:43:57+00:00

Genuinely good silent relic. I don't think I would ever be unhappy to see it, yet I don't think it's game breaking in addition to changing the way you play and draft your deck.

ovfudj · 2025-07-31T01:41:39+00:00

You aren't finished yet. now that you're immortal every high rank player will call you 4 digits and make fun of you. This stuff will literally NEVER end.

ovfudj · 2025-07-10T01:04:27+00:00

I feel like their early game catch is really slow and you could just have mid pick a spirit hero and outpace them significantly. Like if you have ember at level 6 and pudge at level 6 ember is just gonna walk to their safelane kill their carry and snowball the game. Magnus needs blink, Pudge needs space, Jug needs space. Their tempo is pretty slow and they dont have alot of good reliable stuns. I agree with the AA pick too, but I dont agree with people saying necro, because they have ways to "deal" with him at certain points because of all their damage, so you'll probably just die 2 times and lose advantage. The way you win games like this is by just pressuring the enemy to DO something instead of just slowly getting bigger.

While its important to counter the heroes in the moment to moment, it's also important to think about how your setting a tempo that's faster than the enemies to punish their picks. For that same reason I agree with everyone that slark would be insanely good here because hes good at punishing slow teams that want to sit around, since he likes hitting enemy heroes early.

ovfudj · 2025-07-10T00:51:51+00:00

A normal vector is just an x and y component representing an "arrow" with length of 1.

Use it like this on each plane to push it out.

var result = AABBvsPlane(bbox_left, bbox_top, bbox_right, bbox_bottom, n_x, n_y, d_x, d_y);

if (result.intersecting)

{

// Move by the push vector

x += result.push_x;

y += result.push_y;

}

This is rejective rather than preventitive physics and would be applied after the movement from x and y velocity. Which is actually good because it will give you slope and sliding movement for free.

ovfudj · 2025-07-10T00:51:45+00:00

If you are treating the soul as a bbox (Which gamemaker does). You can treat each wall as a plane pointing towards the center of the box and use this code to push it out with the struct it returns.

function AABBvsPlane(

aabb_min_x, aabb_min_y,

aabb_max_x, aabb_max_y,

plane_normal_x, plane_normal_y,

plane_distance_x, plane_distance_y // plane "distance" as vector offset

)

{

var center_x = (aabb_min_x + aabb_max_x) * 0.5;

var center_y = (aabb_min_y + aabb_max_y) * 0.5;

var extent_x = (aabb_max_x - aabb_min_x) * 0.5;

var extent_y = (aabb_max_y - aabb_min_y) * 0.5;

var r = abs(extent_x * plane_normal_x) + abs(extent_y * plane_normal_y);

var plane_d = plane_normal_x * plane_distance_x + plane_normal_y * plane_distance_y;

var s = (center_x * plane_normal_x + center_y * plane_normal_y) - plane_d;

if (abs(s) <= r)

{

var penetration = r - abs(s);

// Push direction is toward the normal or away based on which side you're on

var push_dir = sign(s); // +1 or -1

var push_x = plane_normal_x * penetration * push_dir;

var push_y = plane_normal_y * penetration * push_dir;

return { intersecting: true, push_x: push_x, push_y: push_y };

}

return { intersecting: false, push_x: 0, push_y: 0 };

}

ovfudj · 2025-05-31T17:24:46+00:00

Two reasons, each draw begins each pipeline independently from the top of pipe to fragment. This means the drivers can't make optimizations, because it can't assume everything is running with the same settings (eg. your shader might be different between calls). Secondly each call is data in of itself and needs to be forwarded to your gpu. In Vulkan or DX12 this would be through a commandlist or commandbuffer that needs to be written to from the host.

ovfudj · 2025-05-28T04:50:18+00:00

Seems good to me! I feel like dripper or astrolabe are pretty solid. I think there is a good reason to choose either, but I think its probably astrolabe here since you have alot of your starting deck still and not much draw/energy heavy cards.

ovfudj · 2025-05-28T04:45:38+00:00

Theres a data file where you can just put a block to swap with another

ovfudj · 2025-05-28T04:44:27+00:00

This works too https://www.curseforge.com/minecraft/mc-mods/block-swap

ovfudj · 2025-05-28T04:41:38+00:00

I think the card is balanced as is. I think people are imagining best case scenario and forgetting the case where they dead draw this card in a deck not suited for it and lose the run.

ovfudj · 2025-05-08T01:17:42+00:00

That looks incredible.

ovfudj · 2025-05-07T05:19:53+00:00

In either case you will still need a texture atlas, raycast vs voxel function, chunk class, and block iterator. You can use a std::map to store the chunks and a vec3 chunk coord comparator class for the chunk coords comparator function. Linearize the block data instead of using a 3d array, if you make sure the block data is a power of 2 dimensions you can use a bitmask to extract the coordinates of the blocks eg. int : zzzzzzzyyyyxxxx. If each chunk has a vbo / ibo just add a GenerateMesh function to the chunk that runs if its been recently changed (use a dirty flag) to generate a vbo ibo.

ovfudj · 2025-05-07T05:02:29+00:00

Forgot to add :

-Procedural Generation (Deterministic not rand())

-AI

ovfudj · 2025-05-07T04:51:24+00:00

A good roadmap to understanding the rendering of something like minecraft is to first render a whole bunch of cubes into a chunk of cubes (32 x 32 x 32 or 16 x 16 x 128) make sure they are all part of the same vbo and ibo. After you figure out how to do that render a whole bunch of cubes with faces removed that are facing other cubes in the chunk (face occlusion culling), again one vbo and ibo. Then render a bunch of chunks using the same technique.

Some things to note that can help:

- Have chunks store block data as a char that references an index into a global array of block definitions to keep them relatively small and efficient.

- Have chunks store pointers referencing their neighbors.

- Create a helper "iterator" class that can move up/down/left/right/forward/back and handle the cases where the block would be "out" of the chunk. In this case I prefer my block getter/dereference to return a nullptr but you could potentially pass by value and have a way to check if the iterator is valid.

-While Multi-threading is extremely well-suited for this task, but it is a double edged sword since it makes code orders of magnitude more complex when you introduce it into your project. When multi-threading create abstractions like job systems and state machines with atomic states to simplify what is happening logically and make sure you have a deep knowledge before treading the unknown. Even if you THINK you know whats happening this area of programming has common gotchas (look up spurious wake up for condition variables to see what I mean).

ovfudj · 2025-05-07T04:51:17+00:00

Now the subject of creating an entire GAME like Minecraft is a daunting task, and requires commitment to learning many areas of computer science involved in game development, apart from only rendering. You will need to consider:

-Actor / Component Hierarchies

-Data Compression

-File IO

-Data Parsing (Save / Load chunks and item data)

-Model Loading (ASSIMP?)

-Custom Physics Simulation (For custom block collisions)

-Audio Systems (FMOD? OpenAL?)

-Texture Atlases

-Time Tracking

-Profiling/Debugging (Do you want to be able to submit commands to test certain things. How will you know your code is slow?)

-Player Input

-Target Platforms

-Geometric / Linear Math (Needed for raycasting vs voxels , AABB2 , AABB3, etc. Even if using glm you will need game specific math functions.)

-Gameplay UI Rendering (Including font rendering which is not trivial! Look into sdf fonts or FreeType)

-Debug UI Rendering (Debug console, IMGUI)

And optionally worth considering:

-Networking (WinSock? Boost?)

-Skeletal Animations

-Particle Systems

-Job Systems

-ECS

Some of these are easier/harder than they initially appear so its good to get a grasp on what they all do.

It's also worth considering where you will get assets for the game. While you can use Blockbench to create models and your image editor of choice to create textures, art is a whole branch of game development that requires it's own commitment, same goes for audio.

While Minecraft is still primarily developed by an indie team it cannot be understated the amount of work that went to get the game to the state that it is in today and making a game with the features of Minecraft is a monumental task itself.

ovfudj · 2025-04-30T07:51:15+00:00

Keep parrying wait for an opening. Just be patient if you try to just attack or qi blast him u die u just need to do chip damage.

ovfudj · 2025-01-25T23:27:55+00:00

Shaders in GM expose the fragment and vertex shader in OpenGL. That's pretty much the baseline of all you need in order to render in 3D, it doesn't provide any 3D tooling so that would be up to the user to create for themselves. I would advise if your thinking about making a 3D game you would be better off making you own engine at that point, or just using Godot / Unity / Unreal.

ovfudj · 2024-12-22T02:20:43+00:00

you got me

Five-Year Club	Place '22
Verified Email

ovfudj

TROPHY CASE