Jump to content
  • Advertisement


  • Content Count

  • Joined

  • Last visited

Community Reputation

542 Good

About Renthalkx97

  • Rank

Personal Information

  • Role
  • Interests

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. Renthalkx97

    I would like to appeal my banjo

    I believe I was wrongfully banjo'd and I would like to be unbanjo'd at once Thank you
  2. It also appears that the address itself will have some bearing on whether or not the internal ROM is enabled. This is where things turn into I have no idea what is going on
  3.  It mentions nothing of $FF50. In no documentation is this address even mentioned except in very high-level overviews which explain that "writing $1 to $FF50 disabled the boot rom". It doesn't get into what the actual hardware / circuitry is doing.   Every other hardware address is documented except for this one.
  4.   Yes, the cartridge ROM is mapped to $0000 - $7FFF. However according to the following documentation, when CS2 is set, only $0100 - $7FFF is mapped:     So would writing to address $FF50 set the chip select to permanently select the cartridge ROM?
  5. I am researching the Nintendo Game Boy's hardware and due to my non-existent electrical engineering background I am unable to understand some of the technical terms and events that are occurring at the circuitry level.   Upon powering on the Game Boy, execution starts at $0000 with the internal ROM which contains the boot program. When a value (appears to be $1) is written to address $FF50 the internal ROM is disabled and $0000 - $0100 of the cartridge ROM is mapped back to that address space. The above image shows the hardware layout of the CPU, address bus, data bus, address decoder, memory selector circuit, internal ROM, external ROM, and internal RAM. It was my understanding prior to reading https://www.google.com/patents/US5134391 that when you wrote $1 to $FF50 it changed state of some piece of hardware which controlled mapping the address space. My understanding was partially correct. From reading the patent documentation I discovered that the MSC sent out a chip select signal, CS1 and CS2, that somehow enabled/disabled the internal ROM and external ROM respectively. The confusion lies within the fact that when the CS1 signal is sent out it appears that only the internal ROM is enabled, and therefore external ROM is non-accessible and and vice versa when the CS2 signal is sent. That is fine and dandy, however I don't understand how that signal enables and disables the ROM's. Also when CS2 is sent out and the external ROM is enabled, only addresses $0100 - $7FFF are mapped. How are the interrupt vectors and what not between $0000 and $0100 accessed if the memory isn't mapped? It appears that there is no state that allows the whole $0000 - $7FFF of the external ROM to be accessed. When CS1 is set you only can access the internal ROM and when CS2 is set you can only access a portion of the external ROM.   I hope that maybe somebody could clear this up for me as I am completely lost at the moment.   Thank you, BagelBytes
  6. Hello everybody. I have dedicated countless moments of my Friday afternoon in search of the true answer to a question that once was thought to unanswerable. Today, ladies and gentlemen, I present to you my findings Pay careful attention to the very intuitive use of my very own "KINDA_EQUAL" algorithm to determine if two floating point numbers are acceptable to be considered relatively equal. Many seconds have went into that algorithm and it has proved itself today. I hope that everybody can accept this for what it is; Cold, hard facts proven by a the above professionally developed program. Thank you everybody, Bagel
  7. Renthalkx97

    New lightweight IK library

    I have no feedback. Nice work, however!
  8. Renthalkx97

    Advice on Pong for Beginner

    Make the AI paddle follow the balls Y position except only allow updating of the AI paddle AFTER the ball has crossed over the center median into the AI's territory. This adds more realism along with also making it much easier to beat.   Example: if(ball.x >= screenWidth / 2) { if(ai.y < ball.y) { ai.y += ai.speed; } else { ai.y -= ai.speed; } } Also, I would try to incorporate changing of the balls trajectory based on where it impacts on the paddle so that the player can try to out smart the AI rather than a fixed set of patterns that the ball will follow. E.g. if the ball hits close to the center of the paddle, it should bounce off at close to a +/- a few 0 degree angle, but closer to each extreme of the paddle, it should bounce off at a more harsh angle.
  9. Wow really? I must of been looking at the architecture of it wrong them. It appeared to me that the Application class was the root of the engine and from there initialized all of the subsysems.
  10. Thank you everyone for the replies.   @Sean I agree. I can see how inheriting everything from some base app class can cause issues and make the code much harder to maintain. Although I don't believe my project will reach that amount of complexity anytime soon, no sense in writing something I'll have difficulty in expanding on later.   And generally, I do tend to favor composition over inheritance, I just saw how Urho3D did it and it sparked my interest. Nonetheless, I'll be doing some refactoring most likely.   Thank you again for your guys' input!
  11.   They still do on Windows. It's called SDL_main (the macro), I believe.
  12.   Yeah, I considered using templates, but it still wouldn't be possible to do this exactly using them. I just really liked the idea of just simply extending a built-in class and leaving it at that. You don't need declare any objects/call any functions. Perhaps I am being too user friendly, though. I don't know. I just wanted to get some opinions on it. It's not a deal-breaking feature I need to have by any means.
  13. Hey! So before I explain what I'm doing, I'd like to first off say I got this idea from the Urho3D Engine http://urho3d.github.io/   Basically, they have the Application class as the core of their engine, and you inherit your own application from that class. You then implement your own versions of the relevant methods. There is then a macro that is called that you pass your app's class name to which essentially creates an object of your class for you and does all the internal initialization. So in other words, you have zero interaction with the internals of the engine. You don't need to explicitly call any functions to start up your app. The macro takes care of all of that.   Simplified version: #define APPLICATION_MAIN(applicationClassName)\ int ApplicationMain(int argc, char **ppArgv)\ {\ applicationClassName application(...);\ return application.Run();\ } And the application of this: class MyApp : public Application { }; APPLICATION_MAIN(MyApp) The alternative to this as far as I can tell is having the user manually instantiate their class inside of some designated platform-independent main function that gets called from the platform's main function.    Eg: int SomeCustomMain(int argc, char **ppArgv) { MyAppClass myApp(...); return myApp.Run(); } I like the idea of the user not having to directly instantiate their class (since it's done indirectly via the macro), but I am wondering if there is a way to accomplish this same feature without using a macro. I have yet to come up with anything. This is using the preprocessor to manipulate the source to use your derived class name instead of the base class name. And that's not possible via any language features, so I don't know.   Any ideas?
  14. Renthalkx97

    Cube-y Escape 2 [GAME RELEASE]

    Fun game. I think you did a good job. One thing, and I'm fairly confident that it may be on my end, sometimes you will continue moving for a good amount of time after you release a key. Other than that good job!
  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!