Video

RIP

This looks like it's made in GoldSrc

Don’t portals get destroyed when the object their on moves?

that wpuldnt work because quantum Tunnels destabilize and Collapse when moving

Whao, now we can play with blurry fogs in VR! 😆

If all else fails, do a 2005 Valve move and port it to the original Xbox. Its probably a horrible idea... but you _did_ get it to work on the N64.

But what if the portal stops half way through swallowing the object?

The "solution" in a fan made demake. If you're going off what happens in game, then the real answer is that it gets stuck without going through.

Ah, my favourite error message that means nothing to the user: "object reference not set to an instance of an object"

Fun fact: if you cross your eyes just right, you too can see this in 3D.

you said you are making your own engine? can you release some? I will be trying to get JavaScript to run with this. send me some.

Portal para Android

Idk if it is possible, but lately I've been experimenting with re-coding a game through the game it self, for example in Minecraft each block has a binary code to identify it, there is a way to "combine" the first part of one block and the last part of another, therefore combining two blocks into a new , deferent one. What I'm saying is that couldn't you glitch the game when you use an id? With classes I don't think its possible, but with ids it can be done.

nice dob

goldsrc portal be like:

Portals cannot be moved, as they are not wormholes, but quantum tunnels (portal gun is officially called "Quantum tunneling device"). The energy comes from the miniaturized black hole that's inside the Portal Gun. The Quantum Teleportation concept is used.

He says objectoriented is overrated and then makes his own object orientation😂

Ugh I felt this. Was looking at some stuff today that I wrote a few years ago and hoo boy... Definitely solving some imaginary problems there

Yeah stale refference manipulation is what breaks OOT its serious stuff

"You might be optimizing code that only gives you nanoseconds of improvement." Kaze Emanuar: And?

That is very much like my current ECS works (in PHP. OOP is definitely overrated) 👍🏻 I wish i would've had that advice earlier, I've always added more and more features 😅 Though, i have developed that behavior because i kept rewriting everything in my code, especially APIs

Hey James random question, what mic is that? thank you

I'm not sure if you can publish a game that used proprietary engine on steam without contacting them directly...

do you think a game like Zelda: Phantom Hourglass for the NDS would run on N64?

I liked the old thumbnail and title better because it was more understandable

I always find it painful to see how many massive budget games are still just made with the Unreal engine. These games have so many resources yet they're still not building an engine that would specifically serve the game they're creating. I really wonder how many unnecessary calculations are constantly being made.

Nice one.

Haven't cited KISS, Keep it simple stupid... Also KISS and dont OOP.

You always give off “smartest and most relaxed college professor” vibes. Always great videos!

I'm not sure I want to go back and refactor my code but this makes a lot of sense. Especially the entity ID system.

For anyone wondering: the approach that unity uses is generally called Entity Component System (ECS), and it's not even associated with OOP, rather tending to be used alongside data-oriented design (the approach could be summarized as: for every subsystem responsible for a given component, build a flat array of the relevant data from the relevant entities, that is then simply looped over without any pointer chasing)

It is perhaps noteworthy that the components pattern mentioned around 3:40 is also possible in C, even though C is not an object oriented language. Simply by using instances of structs and pointers. E.g. have a struct GameObject, which has pointers of structs Damageable etc. If the damageable pointer is NULL, the gameobject doesn't have that component and so on. In this particular case of an N64 game this exact implementation of the pattern might be inefficient due to memory limitations though (not sure).

Writing re-usable code is hard, because you don't know how you'll want to re-use later, and you're likely to end up with code that's annoying to use twice. It's much easier to write the same-ish code twice, and compress them into one if it makes sense.

portal doesn't work on moving surface, it just dissapears if you start moving the platform

You're not the only one critical of object-oriented programming. I've heard that many authors of high-performance game engines eschew object-oriented programming. Instead they do what's called data-oriented design. They say it is more performant because it reduces memory accesses and improves cache locality. In some cases, it makes it possible to use SIMD instructions.

"Write reusable code" conflicts with "only solve problems you have right now" and "keep it simple." The desire to write reusable code is what causes writing a game engine instead of a game. The way I avoid this is by extracting reusable code. I write code without thinking about reuse, and if I notice duplication, I remove it by refactoring. This is easy to do in the refactor step of the Red-Green-Refactor TDD loop.

such good advice, and explained so well. thank you.

I remember an old Gamasutra article talking about a game having a lot of issues with its physics engine. A new person came in and made the observations that even though it was a 3D game, all the collisions could be done in 2D instead. The new code was simlle and efficient and got the job done. I think about this kinda thing a lot when people talk about using off the shelf game engines. How much is your engine doing that is unnecessary for your game?

i probably will never understand why people care this much about the n64, but i'm glad people are working on it anyway.

My tip for writing a game for a limited system is to A) don't do it B) if you really insist then use one of the open source engines such as Doom [1-3] or Quake [1-3] and go from there. However, I do completely disagree with you regarding object oriented programming in C. You absolutely can do it and I do it all the time. There are only two concepts in programming that you should always say no to using and that's recursion and recursion. For all else, moderation is the key. Use a moderate amount of the concepts, only as they apply to the problem you're trying to solve. Towards that end, you absolutely can create an object system for your game engine, but if you're targeting an N64, maybe consider something much more simple.

The game link is not available, could you pass another link?

I wish it were as simple as supplying an emulator along with the ROM with the Steam package, but without a BIOS, Valve wouldn't even consider such absurd roundabout distribution, that's a poor user experience, that's something they never had to consider supporting. Unfortunately Portal 64 is just a drop in the ocean to Valve.

A question about one entity doing something to another one (eg. damage). Is an unit authoritative enough to direct apply damage to another one? Or that's up to another system?

6:27 to be fair, the number still is a reference, its just a managed one.

And now to make it scalable use a message queue paradigm 🤣🤣 Edit: I'm mostly joking because I don't know what N64 systems are capable of and most of my game dev knowledge comes from server-side code. I'm nevertheless curious if zeromq or the like can run on N64. Tho given that N64 seems to be single-threaded I doubt there's much efficiency to gain here, except maybe to simplify the code required for batch processing of multiple events as an optimization.

One thing to add to your "don't optimize now" remarks, I tend to follow the same ruleset, and then love running my engine through something like perf or the performance analysis tools inside Visual Studio or Xcode (instruments) to check how much time my code is spending in various functions. Quickly helps me find performance bottlenecks and narrows down potential optimization points.

I'm not a programmer and I understood what you said. Thank you! And looking forward to more of your game updates.

The second rule in my opinion is the most important rule in all of programming. At my work, we have a colleague who was tasked with making an automation script for our infrastructure, related to our monitoring. I had a couple other colleagues berate him with feature requests. I kept telling him, if a feature is not needed for the usability of the task, it can be made later. I am now re-writing it from scratch because it became a complex unmovable and unusable spaghetti code with hard-coded values that were inflexible, and dependant on external systems. I wrote the entire thing in 3 classes, and can be configured with 1 configuration file. I have added 2 features since, which allow us way more flexibility and not only automate what needed to be automated, but we can extend the original capabilities of what we were using. Simple, is better than capable.

Out of curiosity, why do you hold a microphone stand that was meant to put on at able in your hand, bashing the cable into it? Is this programming ASMR? 😀

You're by far one of the coolest people out there.