Jump to content
  • Advertisement


  • Content Count

  • Joined

  • Last visited

Community Reputation

384 Neutral

About Flonk

  • Rank
  1. Flonk

    Planet names (a lot of them)

    So what you probably want is a generator based on Markov Chains. You will still have to sift through the results, because they produce some nonsense, but at least you will have a list of potential names to choose from. I played around with this technique for element names and it produces surprisingly believable results. You can try this one (it is not mine but made by some kind soul). Instructions: Put all the names you have as a space delimited string (Destea Agrillon Trounia Eitrion ...) into the input field, NO linebreaks. Set the Order (the first number at the bottom) to "1" so that it actually takes apart and rebuilds the words and not just phrases (you are not mutating natural language). Set the Output size (the second number) to a high value (2500 is default and should suffice).   Then you can click go and sift through the output. You will get your original names in the output but also some new names. If you still need more, just put the new list with acceptable names into the Input, rinse, repeat.
  2. I think what you really want is a clear seperation of space and ground combat (duh) as well as some mechanics that tie them back together. Your "Space Controlled" meter is something that would probably work quite well, maybe you should also count planetary defences into this, so that a defender can really beef up the planet. To that end the bombardement should actually be capable of destroying those defences (maybe at a cost for the bombers or only with high cost long range weaponry or expensive rockets that cost each shot). The Ground Combat can be handwaved by saying that all Ground Forces are under heavy shields (plenty of room for Power Generators on a planet) or in deep bunkers and attackers will probably want to take over the industry so no bombing that. Also I think the distinction of the Ground Forces into defensive and marines is quite smart: You can have a defensive strength relative to the planets population times some other factors (drafting? ground force tech) and have the marines as a special buildable unit. That way you always have a strong defensive force and the attacker needs to commit to an attack (in this case planets should be actually valuable).
  3. Flonk

    Need help with boss ideas

    A boss that (plottwist) eats you and you have to kill it from the inside (or maybe you have to get eaten?)   A boss that is trampling around in some ruins and you have to line up shots on him from certain spots but to get there you have to avoid him seeing you climb there (basically stealth).   A boss that is so tought that after stabbing it, it just runs away... with you still clutching the weapon. So you will have to do some rodeo stuff to wear it down (jump/duck debris, whack on other debris, stab again when it turns rapidly so that you don't fall of)   A boss that can only be seen under certain circumstances (only in moonlight -> cut vines) and that preys on you at certain points (but leaves clues as to where it hides).
  4. Flonk

    2D RPG in Python (Questions)

    So what your friend talked about, the SDL, is not actually a language but a library for Graphics. This library has a version for Python, called pygame. Since you already have some experience of modifying scripts, learning python should not be all that hard. What will be hard however is designing a game from this relatively low level. With Python and Pygame you will have to do a lot of legwork, but in turn you get complete freedom over every aspect of your game. Learning Python is rewarding in and of itself so starting there is probably a good idea. And while you learn it, you can think a bit about how certain concepts might be used in a game. The next step would then to make small games and come back here for all the questions that will invariably turn up. About the choice of an editor like Tiled: I used it only shortly but it seemed to support all I needed, there is also the Ogmo Editor, which also looks nice. But until you have to decide on one of those, you should first make pong or snake with Pygame.
  5. nothing to be sorry about, just constructive criticism.      Oh sorry, your first post was hard to understand. self.tilemap.update(dt / 1000., self) tilemap.update() takes 3 arguments, self(i.e tilemap), dt, and game. Second self indicates to 'game' instance, which tilemap is a member of. And since we're in scope of game class. we pass it as 'self'.     Sorry for my post ^^a.Now i don't understand how game can be an instance  .Thank you   P.S: i only know how to make instance like this: a=classname() ^^a.     Let us walk through this code: First off is if __name__ == '__main__': pygame.init() screen = pygame.display.set_mode((640, 480)) pygame.display.set_caption("Pyllet Town") Game(screen).main() I think everything is quite straightforward except for the last line: With Game(screen) you create an instance, but then it gets funny, because on that red hot instance a function is called (with .main()). Notice, that we do not take a reference to this new instance (we have no assignment). That means that the instance will be unreachable as soon as the function returns, but since the whole game runs in the main() method we are comfortable with that. So now we look at the main() method: def main(self): while 1: self.tilemap.update(dt / 1000., self) This is where things begin to get python and your confusion probably stems from: From the Signature ( main(self) ) we can see, that we get passed one argument, the reference to the instance which this function is called on. This instance is of course the instance created with Game(screen). The tricky part is, that python passes this argument implicitly for every member method, which is why you don't see it in the call ( .main() ). The next line is just the obvious main loop almost all games run in. But then we get another strange line, which is easiest to understand when dissected: self still is a reference to the instance of Game, so we are looking up it's tilemap (a reference to a tilemap instance) and call the function update on that tilemap instance. This tilemap takes two arguments: The time that has passed since the last frame as well as the Game instance currently running the main funcion (probably to do some draw calls on that game object). The update method itself will look like this: def update(self, time_elapsed, game): #do something What is important to understand is, that the self of the update function is a reference to the tilemap instance while the game in the update function is a reference to the game instance (we just handed this reference over by putting the self reference of the main function into this argument position).   I hope this helps, scoping and lifetimes can be quite confusing.
  6. you beat me to the post. @Kurai: this is the correct solution, next time you could specifically point out the line you are having trouble with (I only now saw it)
  7. The self is a mechanism for accessing the Instance of the Class, that is executing the function. Objects in Python are basically dictionaries, consisting of name:value pairs. To change the value of such a pair you need to explicitly say which object is to be affected (you only want one tileset to change or one player to move). In order for python to know which object you refer to, you use self: Whenever you call a function on an object the first argument passed to this function is a reference to the object executing the function. Python adds this reference silently (you don't need to explicitly pass it on call but you need it in the definition of your function). Other languages resolve everything on a local scope first and then go up to the global scopes. Basically it is all about scope resolution (something that comes up quite often), which is something like connecting you when you call someone. In that case you need to dial the prefix if you want to call someone in a different area. The thing with python is: you even need to dial that prefix for stuff in the same area, but python is nice and hands you the prefix.
  8. You might want to look into FIFE, while it is written in C++ it seems that your game will be written in Python, which is a language worth learning, but it seems like you can do games in C++ as well. That said, I never used it and it is quite old (inactive that is), so you will have to look whether you like it. You mentioned that you already looked at some projects, maybe telling us which you didn't like will keep us from bringing them up again.
  9. Flonk

    Types of aliens (sentient)

    Birds - Avians Bears - Ursa Wolves - Lupians If you want to go a little further you could have created civilisations (robots or silicoides) as well as other funky stuff like beings of energy (kratorians)
  10. Flonk

    Football (soccer) physics

    Most of the slow down at high speeds comes with drag, which scales quadratically with speed. So just have a new_speed = old_speed - old_speed^2 * coefficient and tune the coefficient until it feels right.
  11. Flonk

    Your focus as a creator and consumer?

    1) I tend to start with charactes but often that is just a point of cristallization from where everything grows.   2) I think that some games can get away with lopsiding characters for world (as you said, elder scrolls did not have that memorable characters). And imho the world of Far Cry 3 was nice and all but nothing compared to the intensity of Vaas (which was a combination of writing as well as acting). In that game I felt that the characters were a bigger focus and the story was something that just grew out of them interacting.   3) I think those are actually the main points. I think Writing About Dragons had a lecture that talked about those three as the possibilities to "seed" a work.
  12. Isometric is fine for turn based stuff but for everything requiring real-time movement I dislike it.
  13. Okay so your problem is probably not SDL itself, but how to build your code. SDL is only for the output, all the game logic has to come from you. So what you need is a 2 dimensional array for the field, in which you save the states of each space. To render that field you go over it and tell SDL to render something at the appropriate spaces.
  14. Flonk

    Another word for "Spells" or "Blessings"

    miracles, wonders, interventions
  15. Flonk

    Names for a "Death Star"

    Yes, something like this, gimme more names like these:}   [...]   As you wish: Bastille Class, Citadel Command Station, Fortification Superheavy Battleship, Castle Control Plattform That about runs my synonyms dry, but I can offer you some german translations if you find them to sound bulkier or heavier: Bollwerk, Festung, Zwingburg (this one is a fortress built to control area)
  • 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!