Aurora 4x
Other Games => Pulsar 4x => Topic started by: Antagonist on August 07, 2012, 02:10:21 PM
-
Well, 2 people like Pulsar 4X, and we even have a forum by that name now, I guess we have a name.
For those just tuning in, this is the board for the project of creating an up to date fan sequel of the popular Aurora (a game I assume you are all familiar with it).
We have Steve's blessing and Erik created us this nice sub-forum.
This thread and forum serves as our public face for talk about the project.
Details about repository will follow shortly. Planning an discussion will happen here.
DevEdit:
HTTP Repository Link: https://github.com/Pulsar4xDevs/Pulsar4x.git
SSH Repository Link: git@github.com:Pulsar4xDevs/Pulsar4x.git
Wiki: http://pulsar4x.pentarch.org/wiki/
-
Until we actually have a wiki or shared googledoc or something for design, I'll post some namespace structure ideas here:
I am seeing a lot of public interest PMs sent, quite a few community members are interested to help, though many of them don't have C# experience. I don't have the utmost faith in casual crowdsourcing of dev work, and I think the majority of work will still fall on a few dev's shoulders, but I do believe in giving perhaps not fully dedicated wannabe contributors the opportunity to help out. I advise we get a ticket board up, something listing small and large tasks we need done, whether coding a window, a GLSL shader, writing, translations, icons or GUI art, perhaps 3D models later... We can then point any interested parties to one of them.
Back to design. I'm not making any decisions in this about gameplay beyond what Aurora already makes, but this decision needs to be made in order to kick off the repository.
The following assumes a full MVVM model:
Pulsar4X (solution)
Pulsar4XGTK (project)
-Windows
-Dialogs
-Controls
-Images
-ViewModel
Pulsar4XLib (project)
-Entities (database plain data entities)
-ModelView
-Stargen
The namespaces will read basically Pulsar4XGTK.Windows etc
The model, context, utility, maths and constants classes don't need their own namespace and will be directly in the Pulsar4XLib namespace. I am considering advising to drop the ModelView folder and have the ViewModels connect directly to the Model for greater simplicity in this case which I guess would make it more MVC? Either way I don't want a single line of gameplay logic and code to sit in the windows classes ideally. How well this works for GTK I dunno, I come from the WPF direction in my current dayjob.
As we continue we'll add more namespaces. Obvious ones seem to be for AI, Technology, Combat, economy etc and will primarily be added to the Lib project as we expand.
Basic UI Planning:
[Welcome Screen/Select Game] <--> [Main Window]<-->(SUBWINDOWS!)
^
[New Game Window]
Okay, not exactly sure what to do about the main window, just that while not broken it is def one of the more non-standard parts of Aurora compared to other games/apps. The Economy menu is certainly one of the most used windows in base Aurora, so I feel its integration with the main window would be a good thing. If we integrate EVERY window it might look more like Stars! (http://wiki.starsautohost.org/wikinew/images/7/74/Stars_screenshot.png) but unsure whether that is good or bad. Alternatively I was thinking something with Ribbon-like tabs to switch to different functions? I play with 2 screens though and liked having system map on one screen while economy and other windows on second...
Either way I feel this is a good place people can contribute. If anyone can make some mockups of some ideas what the Aurora windows SHOULD look like we will properly consider them.
One of the safer windows to dev early, and one I would like earlier rather than later, might be the F9 window. Pick a system, list its stars and planets. The columns of stats for each planet might change with design, but I don't think the basic look and feel of it will change that dramatically. It would make it easier for me to test out planet generation experiments however.
-
Apologies for the silence of late - rather busy at work dealing with some project handovers and spending far too much of the last couple of weeks reading functional specs. . . Plus, there's that sports thing which is a little diverting ;-)
I was doing some thinking on my way to work this morning about project structure and the suchlike. This is really a reply to the post on the Aurora II thread, but better put here.
Source Control - I'd have to throw in my hat for using Git, if only so that we can use Github. Given that Github has native Windows and Mac apps that remove a lot of the learning curve of using Git, there shouldn't be many arguments about complexity especially when Github gives us a lot of benefits for free as well - and it makes it easy for non-core contributors to pull sections of code that are of interest to them and push back any changes.
Windowing - I'm not sure what the benefit of using GTK is. Winforms is well supported by Mono and doesn't require extra libraries.
OpenGL - If we're to go down the OpenGL route for parts of the GUI, I'd suggest we use OpenTK as our library as it's, probably, the most solid OpenGL implementation for . Net at the moment. It also gives us input and audio for free and works across platforms.
Toolchain - Monodevelop can both read and write VS2010 project files, so no problems there. I'd recommend using VS2010 Express if you're coding on Windows though. Some, small, parts of the project will, I'm pretty sure, require VS2010 Pro though - to build the installer at least (Express doesn't support Setup projects). As far as the database goes, I'd recommend SQLite for being cross platform and self-contained.
Modularity - To keep everything as clean as possible, I'd suggest that any significant chunck of functionality be given it's own project. The main advantage is making it easy for people to work on one particular area without needing to worry about how it fits into the bigger picture as long as the interfaces used to access the functionality are kept up to date. It will also smooth to path to making components into plug-ins later - I'm mostly thinking that areas such as System or Planet generation would be good candidates to be turned into plug-ins so that people can pick between different styles of games.
There's probably more ideas to dump, but that's about it for now!
-
I've got VS2010 Pro, so if you need stuff requiring that, I can help.
I'm not a C# coder though. My background is VB and SQL.
-
Windowing - I'm not sure what the benefit of using GTK is. Winforms is well supported by Mono and doesn't require extra libraries.
OpenGL - If we're to go down the OpenGL route for parts of the GUI, I'd suggest we use OpenTK as our library as it's, probably, the most solid OpenGL implementation for . Net at the moment. It also gives us input and audio for free and works across platforms.
GTK was a suggestion of familiarity. I know enough GTK to coordinate/do UI development myself as needed, and have done basic graphics display in it with the Cairo 2D graphics library.
WinForm with OpenTK could work, but would require someone besides me to be a primary graphics/UI contributor.
Thoughts? Volunteers?
-
Until we actually have a wiki or shared googledoc or something for design, I'll post some namespace structure ideas here:
I can set up a wiki, along with a ticket system and/or a project management system here too.
Through the host, the options for project management are dotProject, phpCollab, PHProjekt, ProjectPier, Mantis Bug Tracker, Feng Office, eyeOS, The Bug Genie, TaskFreak, Mound, Collabtive, Eventum.
Ticket systems are Crafty Syntax, Help Center Live, HESK, osTicket, ExoPHPDesk, phpSupport, Open Web Messenger, phpOnline, phpMyFAQ, iQDesk, Trellis Desk, Maian Support.
And it looks like I can put in SVNManager if you want to use SVN rather than git or anything else.
Just let me know what you all want, and I'll do my best to make it happen :)
-
Well, Erik is living proof that a dev team doesn't ONLY need coders.
I've... used project management and ticket systems sometimes, but nothing to do with admin or such. I will leave the choice of exact system to someone else. Wiki we can do with, but repository is main concern for me atm. Yes, we should design before coding too much, but getting the repo up with basic solution and project is like a milestone, a pickaxe in the ground, a sign that we started and the project is actually happening. SVN is an option we can use, I like the possibility of keeping project, tickets, wiki and all together, even better if we can get them all to work together. Still like mercurial, but would seriously drop it in an instant if we can get repo integrated with ticket system and stuff. MrBear suggests git for github... I don't have great experiences with git, but I'd like his opinion on some system Erik can host, or whether github would still be advantageous.
I have my own copy of VS2010 Pro so sorted on that front, but it should not be a requirement for everyone else to have it. The MAJORITY of the project and dev work should be doable with the freely downloadable Express. I dunno if it'll make a difference, but might help if the initial solution and project structure is done using Express just to be sure.
Windowing - I... don't intend to do much in this direction. I can, have worked with winforms a lot, but enjoying WPF and hoping to never have to go back to winforms kinda situation. If you wanna go WPF sure I can help! But won't be portable since mono doesn't do WPF yet. Winforms is familiar over GTK for me yeah, but honestly? If someone is willing to do the work in GTK that's fine. If someone is willing to do work in winforms? That's fine. Solution structure should reflect that though, one option is to eventually(!) put all this on the web, so if we follow proper MVVM and structure patterns we can even have multiple simultaneous UI projects, each using something different, and the backend coders won't care. Whatever windowing system, NO GAME LOGIC IN UI CODE. Ideally... I realise hacks are sometimes needed. Largely I'd like to point out that UI Mockups should be considered somewhat a priority, irrespective of what windowing system we use.
OpenGL - In my ideal mind anything in OpenGL will be post-v1, barring us getting a dev that can focus on GL. It... changes things. Its great and all but yeah. Far as I understand OpenTK is just something we can throw into the project later right? We don't have to design anything at this stage to accomidate for it? Lemme know if I am incorrect on this. If we have to compensate for adding OpenGL now or later that has to be reflected.
Toolchain - I like what MrBear is saying in this. Cept I'd like to suggest WiX as a possible alternative for the installer. I THINK it works with express, plus it wasn't totally horrific last I had to use it.
Libraries - log4j is the one that pops into my mind as required even at this stage of the project. Do this properly at this stage and it'll save a lot of headache later.
Modularity - I agree with MrBear on splitting into projects, just I suspect I might differ on what and where to split. UI should be split from backend yes. Database and entity definitions should stay together... Things on gameplay like economics and combat would be weird to split in my mind... I don't like but can see splitting off system generation maybe? Anything reporting or graphy sure. In short I'd like to hear from him more the modules he proposes. It is important and very relevant to get to an agreement on that soon.
-
I can set up a wiki, along with a ticket system and/or a project management system here too.
Through the host, the options for project management are dotProject, phpCollab, PHProjekt, ProjectPier, Mantis Bug Tracker, Feng Office, eyeOS, The Bug Genie, TaskFreak, Mound, Collabtive, Eventum.
Ticket systems are Crafty Syntax, Help Center Live, HESK, osTicket, ExoPHPDesk, phpSupport, Open Web Messenger, phpOnline, phpMyFAQ, iQDesk, Trellis Desk, Maian Support.
And it looks like I can put in SVNManager if you want to use SVN rather than git or anything else.
Just let me know what you all want, and I'll do my best to make it happen :)
I should mention I can also host mySQL or Postgres databases here too. Should you wish to go that route.
-
I cannot commit to any specific amount of time to help out but I would be glad to help when I have the time.
As background, I am a team lead for a web based software company in the US. Experienced in C#, VB, SQL, WPF & WinForms (prefer WPF). I have used most of the source control repositories and am fine with any of them. I have VS 2010 Pro.
In my spare time I had started a side project to create a game that was a mix of Stars! and Aurora. I saw someone mention planet and solar system generation, one of the pieces of functionality I have mostly completed was a port of the Accrete code to C# and turned it into a more OO oriented approach. It also includes some atmospheric code I found in a fork of of the original Accrete code. I am working on adding moon generation to the code and including atmospherics on the generated moons.
Once a repo is set up, I would be glad to help out when I have time available and contribute what I can.
Rich
-
In terms of development, I primarily focus on Java and ETL for large systems. However, I have also done the same stuff in C/C++. At a higher level, I do systems engineering, project planning, and COTS integration for the USG on a professional basis. If this is helpful, let me know.
-
My preference for github is mostly because I'm (reasonably) familiar with it and because it's got good tools and a good reputation as well as having become one of the more popular hosts for open source projects these days.
Frankly, my real preference is that source is hosted somewhere reputable and reliable and I trust github/bitbucket/sourceforge etc. a lot more than I do someone's private server. Github and bitbucket both have issue tracking and wikis built in, so they cover pretty much all the bases.
If you want to take a gander, this is one (small, simple) repo of mine - https://github. com/elemeno/SimpleMillerRabin
I've love to use WPF as well, but it's not well supported cross platform which is a shame. Unless we went for Silverlight/Moonlight which is reasonably well supported I think. For Winforms vs GTK#, from what I understand GTK# still doesn't have good databinding support and without that it's going to be pretty painful to use for a game with so many tables of data.
-
Pulsar4x Structure:
I've been think that if we split the project into two halves as antagonist wishes we may as well split it into three:
- User Interface
- Database Access
- Game Engine
Repository
Lets go with Mercurial over Git. Antidotal internet comparisons suggest Mercurial is easier to learn.
So: Mercurial or SVN? Mercurial gives us the proven bitbucket hosting. SVN allows us the prestige of having Erik host our stuff here.
-
The only thing about external code repositories you need to look out for are the licensing terms. CodeProject has some odd terms, as did sourceforge if I recall.
-
Github doesn't have any explicit licensing requirements other than stating that by making a repository public you're giving people the right to fork it, which pretty much forces some form of open source license. Since I don't see the point in doing this if it's not going to be open source, that's not a problem for me at least (and I'd suggest GPLv2).
Personal experience suggests that the learning curve for hg and git is identical, but git is significantly more popular so tutorials and documentation available on the internet tend to be better. Clearly I prefer git, but I'm comparatively agnostic between the two - I recall git being smoother on windows than hg, but it's been a while since I compared them on windows (I tend to use TFS on windows, git on OS X and Linux) so don't put too much stock in that as the state of the tools will have moved on. I do notice that github has it's own GUI client which removes the need to know much about git at all - pretty much anything 'advanced' can be dealt with in their client or through their website.
Subversion I'd rather not use though - I think that the DVCS model is better suited for these sort of projects mostly due to the ability to have local branches while you're working on different things and only pushing the end result back up to master, which makes it a lot easier to push discrete changes without breaking master I find.
-
Ok, time to read the fine print.
Bitbucket: Provides private repository hosting... for up to 5 contributors. That should cover a solid core of primary developers, but makes accessing the crowd of associate coders expressing interest difficult. This might not work after all.
SourceForge: Free hosting. May support both Mercurial and Git. Requires us to explicitly choose an OSI-approved licence.
Github: What McBear said. I think I also saw a use clause that explicitly makes us legally liable for any lawsuit against Github in regard to our code.
-
I'm usually fairly busy, but I'd like to help out where I can on this. I've got several years of experience as a lead tester for PC games; once you've got a working engine, I can take a look and see if I can write a test plan.
Once the engine's working, I can also contribute ideas for races, tech, etc.
-
Ok, time to read the fine print.
Bitbucket: Provides private repository hosting... for up to 5 contributors. That should cover a solid core of primary developers, but makes accessing the crowd of associate coders expressing interest difficult. This might not work after all.
SourceForge: Free hosting. May support both Mercurial and Git. Requires us to explicitly choose an OSI-approved licence.
Github: What McBear said. I think I also saw a use clause that explicitly makes us legally liable for any lawsuit against Github in regard to our code.
No matter what you guys decide, I'll give you the best support here that I can :)
-
I sent a private message, but I'll post here as well.
I have some moderate experience with C#, VB.net, and C++. I'd love to lend a hand with this and I have a glut of free time due to my employment situation (which is to say, a lack thereof).
-
... I have a glut of free time due to my employment situation (which is to say, a lack thereof).
Welcome to the club.
-
I'm willing to go with any source control. Since my bad experiences with git seems to be unique to myself, I'm willing to give it another shot.
I have never worked with github before, but from the discussion it appears that MrBear seems to have extensive experience with it and the only real STRONG preference for any source control over another. His experience would also be useful for any advanced tasks we may need to perform. I'm not too worried about the legally liable from lawsuits thing, since the person with the most standing to sue is Steve and he seems okay with it all, not to mention the fact that we aren't making money from this.
Re:sublight's proposed project subdivision:
I have 2 issues. First is that the entities classes, aka new Star, new Starship, etc, should all be together with one another. I would also prefer to keep them close to the main game logic library. If your proposed design keeps entities there, but you are suggesting only seperating the say SQLlite or whatever database specific stuff, I can support that. I feel we should pick a db engine and stick with it, but it is possible to in the future need to say have something that supports MSSQL or MySQL. Just... I personally feel that can still be kept in same project.
I would like to avoid situations where we spawn a dozen dlls in the form of: 'Pulsar4XCombat.dll' that we need in our game. If needed we can go that route, but I don't see any advantage to keeping stuff THAT modularized and decoupled.
Okay, I'd like a show of hands and opinions on some more choices:
Logger - log4j good for everyone?
ORM - What are you guys familiar with? Entity Framework is out due to portability. Two options seen so far is LINQ to SQL or nHibernate. I don't think either is WRONG, but I'm willing to have us use the one most ppl are familiar with. If you have worked with either, or have a 3rd option, please say.
Database - SQLlite has been mentioned, but I have 0 experience with it. Since we're talking multi-platform it excludes MSSQL, MSSQL Express and MSSQL CE, so it leaves me in the noob department. Please discuss and suggest something. I would however advise we try for our PRIMARY SUPPORTED (no reason can't eventually support multiple, but start with 1) database is that it is file based, aka gives us something players can use and email one another saved games, rather than what MSSQL and MySQL usually does where you're not expected to ever manually touch the db file.
Scripting - One thing I would like is if a lot of the data files or stuff like AI was kept in decompiled scripts the player could easier modify. I don't want this stuff distributed and need DB access to modify. Perhaps when you start a new game, the data files are used as initial settings to populate your game file to prevent you messing stuff up by changing techs midgame, I dunno. Perhaps customize the tech tree, or modify the AI of the opponents, change stats of hulls and techs, as well as modify or add to the orders like 'Refuel when fuel below 30%'. Its still up in the air how much we will put into scripts and how much hardcoded, but we should consider designing in the ability to use scripts. Our options are lua, js, vb, json, etc, but one suggestion I'd like to forward is to use C#. Using reflection it is possible to RUNTIME COMPILE decompiled C# files distributed with the game. This will allow modding capability without access to the source (even if open source makes that easy).
Windowing - We seem to be moving towards the Winforms side? I have gotten a few more help offers from ppl in PM, if any of you know your UI, we can still do with someone dedicated to this. Or GTK#, but either way, this is like a developer position wide open for whoever wants to apply.
Design Document - We have a wiki, we should start using it. We need ideas and a roadmap. The first bit of development is fine, we need to get planets and systems and a time passing system and all that up. Whatever game design we choose a lot of that is intuitive. But after that it gets harder. Will we support multiple races on one planet? Multiple factions each with multiple races on the same planet? Do new ship designs need to be researched? New ship parts? What parts are available? What does tech tree look like? How fast do ships move? A lot of this we can just copy over from Aurora, but some of it we can do better, like having contstruction 'ticks' shorter than 4 days. Even the stuff that we copy from Aurora we need to track down the formulas and preferably lay out.
Multi-threaded - This is a fact of modern PCs and a VERY requested feature of Aurora. This will need to be worked into the time and simulation system. We need to figure out what will and what will not create race conditions and we need to establish standards so that we can make what needs to be multithreadsafe, multithreadsafe. I know many libraries are available, we need to choose one and start establishing the standards. These standards are not just for consistency, but also so that devs NOT familiar with multithreaded programming can still contribute and maintain the code. A single person should propably be assigned to the skeletal framework of this initially however.
UI - Again, this is IMPORTANT. The map, the windows, mockups. Whatever windowing system we use, we need to know how the main window should look like. The system and planetary maps is still up in the air, depends on whether anyone is gonna step forward as a OpenGL dev, but yeah.
There's propably still more decisions and options we should look at, but its after 1AM so sleep time now.
EDIT:
@clement: We need to have a nice LOOONG chat. I like what I am hearing from you. Your efforts definitely seem to mirror my own.
I dunno what your approach is, but what I did was take the universe's OOP approach to it [http://universe.sourceforge.net/ (http://universe.sourceforge.net/)], but used the actual code and functions from [http://jms.fmipa.itb.ac.id/index.php/jms/article/view/277/293 (http://jms.fmipa.itb.ac.id/index.php/jms/article/view/277/293)] which is practically identical to that of TerraJ just with some changes, such as extending the dust distance and altering the calculations for safe distances between the planets. It also includes some nBody stuff, but that is not all that involved with the base accrete system.
PROBLEM is... this whole piece of tech based on Dole's stuff is OLD. No real hot jupiters for instance. Also, the planet type system is completely wrong, but not that hard to rewrite. Also, albedos need a serious look at since in this game there will be the ability to change it. Oh, and doesn't support binary or trinary systems, but that isn't too hard to add by just giving stars forbidden zones. And shouldn't allow moons within the Roche limit. Actually take a look at [http://en.wikipedia.org/wiki/User:GabrielVelasquez/101_errors_of_Stargen (http://en.wikipedia.org/wiki/User:GabrielVelasquez/101_errors_of_Stargen)] for some issues with the system. Linked doc is written from a 'Screw you' perspective but a lot of the points are valid.
Okay, and that is just the START of this rant. Gas and Dust densities are not guaranteed to be constant. For one it depends on the snowline where a lot of the water 'gas' turns to water 'dust', which affects accretion. Collissions is another big one, since the dole system assumes fully elastic collissions where the two planets collide and create a new planet, without any mass lost or considering near misses or planetary orbital drifts. I would like it if code could allow collissions to help create asteroid belts, where after a particularly violent collission the planet breaks up and forms a belt. Studies like [http://www.lpi.usra.edu/meetings/lpsc2003/pdf/2000.pdf (http://www.lpi.usra.edu/meetings/lpsc2003/pdf/2000.pdf)] further confuse the issue by making the amount of water available on the inner planets dependant on the formation and locations of the gas giants in the system.
Okay... part of this is my engineer mind trying to overdo this. Absolute scientific accuracy isn't needed, just fun and entertaining is. But yeah... getting a 'basic' system up isn't hard. Its improving it to be better that is breaking my brain.
------------------------
If anyone is friends with cosmologists, I would really LOVE the answer as well as the relevant papers and formulas for the following, would really really help make a better star gen system:
Under modern post-1980s cosmology understanding, assume a Star of mass M and Luminosity L. This planet has a protodisc with gas density G and dust density D. Only one planet ever forms around this star, at orbital distance A and eccentricity E. What would the mass of the accreted dust and gas be of this planet after it has completed its formation and cleared out its feeding zone?
----------------------
EDIT2: The system I'm talking about and modifying, as well as clement seems to be talking about is basically a variation of [http://www.eldacur.com/~brons/NerdCorner/StarGen/StarGen.html (http://www.eldacur.com/~brons/NerdCorner/StarGen/StarGen.html)]. Real cool, but old.
As for everyone offering help... there is currently the original 3 devs: Me, sublight and MrBear. Our ONLY claim to this project is not being best or greatest coders, but just being the first 3 to say 'That's cool! I'll help.' We can really do with more help, we're just still in initial part where we decide what to do. Even if you don't do C#, we can do with help by posting ideas on the ideas thread and responding in this thread about ideas or systems we can use: 'Use github! It worked for me and my project!' 'Don't use SQLlite, it has problem x!' etc. Best way to help right now is talking, giving ideas. You don't need permission for that.
-
Project Division: My suggestion was based on perceived data flow. The UI and GameEngine each take turns updating the database depending on if time is advancing or not.
MultiThreading My recommendation would be to simply split individual star system time advance updates into their own threads. My thoughts are this would give us the best system performance for the least coding effort.
Developers: I too would prefer having another primary developer or two. I feel three is a minimum. Four or five would be ideal.
At the moment our two greatest needs are the UI and the Wiki content/ticket tracking. If needed I can do one or assist with both, but I don't think I can be the primary on both.
Development Phases and Objectives
Tentatively:
Phase 1: Pre-Planning (We are here)
Primary Ideas of interest include what the game should look like and what languages/tools should be used in making it.
- Form a core Developer Team
- Decide on languages, repositories, and tools.
- Sketch out game structure and UI appearance.
Phase 2: Pre-Alpha: This is where we start coding.
Phase 3: Alpha: This is where we make Pulsar4x playable.
Phase 4: Beta: ?????
Phase 5: Perpetual Beta:
I'll take another look at git and githost and see about breaking ground with an official repository some time this weekend.
-
@Antagonist I can try to do some code clean up on the system generation code I have. It is a derivative work of Stargen with some changes to the moon creation logic. I have an idea on how to include multi-star systems, just have not been able to do any coding on it recently (work has been very crazy). I will read those articles you linked to as soon as I have a chance.
Regarding making the Stargen code better, I have always liked the approach of get something that works, get it out and being used, and then iteratively make it better. Trying to get it just right means no one is giving you any feedback.
Databases: If you want to be able to work on Windows/Mac/Linux systems I would suggest Sqlite. With Sqlite you can write to any number of databases and it is very easy to create a new db in game on the fly. To that end, you can have a bootstrap database that stores in-game data like different templates for ship/person/star namings and all of the technology (this data could also be stored in config files (JSON or XML) if we wanted them to be easily human editable). Then each game can be given its own db to store all the needed data for it. It would be very easy to create the new db file and then run a batch of create table sql commands on it to get it setup. I have done this approach in an Android app I am working on.
Logging: Log4Net http://logging.apache.org/log4net/ (http://logging.apache.org/log4net/) is the .NET version of Log4J
ORM: I am a big fan of an ORM called Dapper http://code.google.com/p/dapper-dot-net/ (http://code.google.com/p/dapper-dot-net/) It was created by the team at Stack Overflow and is very high speed. The only thing faster than it that I know of is direct usage of the DataReader object. At work we use a mix of direct DataReader loads and Dapper. It is very easy and straight forward to use. On the other hand, ORM technology should be of major significance in the project. I say this because I would expect there to be an initial load of bootstrapping data when the game application starts and then a second data load when a game file is loaded. After that I would suggest all game data is kept in memory and only written to the database when saving the game. The saves could be automated to take place every in-game month or some other setting like that. This would greatly improve performance and you could save the game out as an entire Sqlite database which would allow you to avoid any leakage of data from one game to another or corruption of all games by an application error in one game.
Scripting: I would suggest LUA for scripting with JSON for data storage in files where you don't want the data in a bootstrap database. On the other hand, for a lot of things like individual orders, it would be a lot simpler on the first pass implementation to simply make each possible order as a code construct that is compiled into the game. The new run-time code compilation stuff in .NET is pretty neat but it has some big dangers that it introduces. If it has problems it can be difficult to identify if the issue is in the changes to made to the de-compiled code or if it is somewhere else.
Windowing: I have no experience with GTK# but would assume it is as easy to pickup as WinForms or WPF. It would give us multi-platform capability but is that capability needed right now? WPF does have many very nice features related to UI manipulation and controls that I do not remember seeing in WinForms. I have not done any work in WinForms for probably 5-6 years though so I have probably missed some developments. I have done a few data collection/input utility apps as one offs at work that have used WPF and found it to be very quick to throw together. It was very similar to what I remembered doing in WinForms just the markup and style of it is much more like HTML when doing the layout.
Design Document: I would recommend that for the first pass, all features and functionality be a re-implementation of the Aurora functionality. Imitation is the best form of flattery. The danger of trying to pick and choose and change the way parts work is that it means the game is not done and usable in a form that can be played with and tested. I am currently wrapping of a re-platforming at work of a piece of 10 year old software. We made the decision early on that we would not add any new features for version 1, it would only have the functionality of the original software. This gave us a great deal of freedom in defining the individual tasks and requirements but also let us take all the requested features and changes, put them in the backlog and then design our new system to allow the future inclusion of those backlog items. Obviously, all of the above does not mean re-implementing bugs in the current system.
Multi-threading: Fortunately multi-threading is very easy in .NET and C# especially in 4.0. With 4.0 a new threading mechanism was added under the System.Threading.Tasks namespace http://msdn.microsoft.com/en-us/library/system.threading.tasks (http://msdn.microsoft.com/en-us/library/system.threading.tasks) This includes the Parallel and Task object which when used can allow very quick and powerful multi-threading. If you are using thread safe collection objects from the System.Collections.Concurrent namespace http://msdn.microsoft.com/en-us/library/system.collections.concurrent (http://msdn.microsoft.com/en-us/library/system.collections.concurrent) then there are very few of the issues that you used to have to constantly watch out for involving locks. The Parallel object will allow you to give it a task to perform (ie: a delegate) and it will analyze the total number of tasks to be performed across the collection of data and spin up an appropriate number of threads for you. As the tasks complete it will increase/decrease the number of worker threads based on how much time and cpu load the tasks are using. It is very powerful and we use it extensively in our software.
UI: I have a mockup I will try to attach to this post that I did for what I was playing around with in my spare time. Like I mentioned before I was pulling inspiration from other games as well and it won't both me if no one likes it.
Regarding how to break up the entire applicaiton into projects, I suggest having 2 projects in the solution to start with, ignoring any unit test projects.
- Core Engine Project - this would contain the following
- Data Objects
- DB persistence code
- engine for processing time
- core AI
- research
- anything else to run the game
- UI Project - this would only contain code for showing the results and data from the core engine project on the screen
This approach will allow for a UI to be done with GTK#, WPF, Winform or whatever. In fact, different UIs could be made to sit on the same core engine. You could deploy this behind a web based UI and run it through a browser. In addition as things get more fully developed, things like the AI can be pulled out of the core engine and made separate dlls for expansion if need be. However, breaking them out now, when there is no code and runs the risk of over complicating the design early on. I put database access with the core engine simply because the odds of it changing are slim to none once serious development is underway.
Rich
-
The system and planetary maps is still up in the air, depends on whether anyone is gonna step forward as a OpenGL dev, but yeah.
The system map we can basically copy from Aurora(which is an excellent default policy), opengl can handle 2d drawing just fine. the planetary map is going to be an issue, one of the issues that I remember in an interview with a worker on an indie RTS was just what a giant pain tiles were. even a star control 2 like map would probably be overly much to expect.
-
I would not really worry about using OpenGL if the game is still going to be Aurora-esque in its interface.
For the maps just put a ScrollViewer on the screen with a Canvas inside of it. Extend the Shape object with some custom drawing code to add extra info around a circle/triangle on the canvas for each object that needs to be represented, star/planetary object/ship/missile....
Simpler in the short term and then later on if the UI is an issue it can be re-worked with acceleration via opengl or DirectX. If we were to use WPF, it will automatically route its rendering through DirectX and the graphics card if the graphics card supports hardware acceleration (ie: DirectX 7.0 or greater).
-
Lua is pretty damn easy to integrate with C#, so I'd be very much in favor of taking that route - it's really not too much more than exposing the functions and objects that can be accessed from the Lua scripts.
If we're using SQLite (which I suspect we will be), then it would be pretty easy to let Lua scripts have some scratch space of their own in the DB as well. However, even though we should approach the code as though it will scriptable, it's really not something that needs to be thought about too much until we're at a point where we've got something cobbled together IMO.
-
GTK was a suggestion of familiarity. I know enough GTK to coordinate/do UI development myself as needed, and have done basic graphics display in it with the Cairo 2D graphics library.
WinForm with OpenTK could work, but would require someone besides me to be a primary graphics/UI contributor.
Thoughts? Volunteers?
I don’t have much UI/OpenGL experience but I’d be willing to take on the role of UI developer/OpenGL if asked.
For my background, I am currently studying a Games Programing course (6 months in to the 2 year course). Most of my experience to date is with C++ and 2D rendering with OpenGL. I have some previous experience with C#/WinForms but it’s been a long time so I’m going to have to dive back in Learn it again.
@clement If you’re going to use OpenGL as part of the UI then you’re better off using it from the beginning. A toolkit like OpenTK makes it easy enough to implement that doing anything else in the short term would likely just be a waste of effort. Also as MrBear stated OpenTK also gives you Input, Sound and a 3d Maths library (not to mention OpenCL) for free too.
-
Oh, good point on OpenCL - it's making me think that orbital mechanics calculations might be very well suited for offloading to the GPU to make them faster. They're really not so different from sets of matrix transforms.
I'd note thought that this falls under the "interesting idea" category rather than the "we should do this category"!
-
Oh, good point on OpenCL - it's making me think that orbital mechanics calculations might be very well suited for offloading to the GPU to make them faster. They're really not so different from sets of matrix transforms.
I'd note thought that this falls under the "interesting idea" category rather than the "we should do this category"!
My thoughts exactly. Though I do agree that it’s something we should think about later rather than try right of the bat.
-
I have some experience with OpenCL and more experience with CUDA. My main issue with any approach like this though is that it requires graphics hardware to take advantage of, and for those without suitable hardware it will need a fallback (yes, I know in theory the CPU is fallback already as an OpenCL host, but in practice it is annoying).
Why not just make a decent enough fallback? I doubt we will NEED OpenCL to do anything here, that is if you want to do a nbody simulation with 10 000 objects or advanced physics with many moving parts, something like orbits of relatively VERY FEW planets isn't really gonna stress the CPU here.
As for timing, I remember Steve thinking about making Aurora II realtime, that is, instead of clicking skip x days, it constantly and smoothly updates, just with ability to increase the speed. We should consider this, even if it increases the computational requirements.
Anyway, noone has said anything about repository in a while, I assume then that github is an okay choice? If so, sublight, mind creating us a repository?
-
Ahh no! I like turn based. Can you imagine trying to design a whole combat fleet while the clock ticks away? Unless, of course, the ability to pause is there.
Another thought- why limit the game to two dimensions? (Sorry, I probably just broke someone's brain.) Granted, the comets and dwarf planets like Pluto are outliers, and most system bodies stay on the elliptical plane, but if the calculations are streamlined... granted, the control scheme would start to get ugly quickly.
A note for the people doing system design- hot Jupiters that orbit a star at close range usually didn't start there. They started out far away, and obliterated everything in the inner system on their death spiral inwards to the star.
-
The main reasons to keep it 2D (imho) are simplicity in design and playability. Plus in a 3D volume anything less than 4 points can be viewed as a 2D plane; so for a battle where two fleets stick in a close formation relative to their distance from each other there isn't much point in displaying it 3 dimensionally.
Feel free to correct me if I'm missing something.
-
When you mention realtime, what model are you talking about? the Homeworld/Cataclysm/2 model? The DEFCON model? the SOTS model? the Rebellion model?
I don't necessarily see any appreciable difference between advanceTimeOneDay, and speedX86400.
On 3D: we can do some 3D gfx, but keep the basic gameplay 2D. I agree that full 3 dimensions has been a hastle thus far.
On the UI/developer front I can also help in that regards, but any UI design I make is going to be spartan as can be.
-
Think of the 'realtime' as auto-turns, just with much faster and efficient turns with smaller subdivisions. And yeah, pausing will be possible.
Note though that this is an ideal, we'll have to see if practical.
-
The Repository: ask again tomorrow. I was getting a little bit of code-overload, so I swore off anything and everything code related this Saturday. So far the break has been doing wonders for my sanity. But yes, we'll try github.
Primary Developers
So we have Sublight, Antagonist, MrBear, Nathan_, clement, and SnopyDogy? Did I miss anyone or add someone who only plans to make periodic submissions? If that's the list I think we have our Dev-Team.
-
I'd like to help, but I have no professional experience or experience at all with C#. Just Python and Ruby, with a little bit of C++. I can try to help with whoever needs it, as I've got time to kill. I would like to throw this food for thought out there as far as the time goes: What I seem to be hearing is something akin to XCOM's model just with a pause button added.
-
Ok, we now have a github repository:
HTTP Repository Link: https://github.com/PsiDog/Pulsar4x.git
SSH Repository Link: git@github.com:PsiDog/Pulsar4x.git
On the UI: Spartan is good, for now. Gameplay first, graphics 2nd.
We ought to plan a real-time Developer brain storm session or two to clarify expectations and direction. Voice communication would probably be the most efficient, but text would be a lot easiest to set up. Thoughts?
-
Well, Skype or Teamspeak would work, if you just want to set up text, I believe there is an aurora irc somewhere iirc. Teamspeak servers are free, but a little clunky. While skype is not very clunky and does have both text and voice for conference calls.
-
I have IRC and the Aurora channel is on my autojoin list.
As for voice I have skype, just not always with headphones on me. Teamspeak is possible, tho I'd have to install that again.
I'll see about getting git to work in the morning.
-
IRC and skype will work for me, but I haven't got a mic so I'd be using the chat functionality there.
-
I have skype, don't have teamspeak would have to get that set up.
-
Writing this while waiting for github for windows to install...
About organisation, i hate formal titles and all but it is true that developers will tend to fall within certain roles in this project. Multiple people may fill a single role and a single person may fill multiple roles, but this I feel is a good initial guide for work subdivision:
Project Head - Creates repos and takes basic responsibility (sublight?)
Build Manager - Primary responsibility for project and build files. Confirms mono compatibility.
UI Dev - Developer(s) of the winforms UI as well as the viewmodels to connect UI to the backend
Simulation Dev - Developer(s) of the simulation and updates, orbits, ship movement, population and resource growth
(Combat Dev) - Developer(s) of the combat system, weapons, targetting, damage and such
Generation Dev - Generation of realistic star systems (interest from myself and clement)
(Scripting System Dev) - If we are doing scripting, a developer needs to maintain the bindings
(Scripting Dev) - Maintains the script and data files
(AI Dev) - Developer(s) of the AI
Meta-Maintainer - Maintainer of ticket system, wiki and such
UI Designer - Mockups and designs for the UI. Doesn't need C# experience
Economy Designer - What planets do
Ships and Technology Designer - What you can research and what it means, how subsystems on ships interact
Artist - Not a graphics intensive app, but we still need icons and such at the LEAST
Sound - While default windows tones can be used, it is possible to do better
(Testers) - Eventually we need someone to make sure everything works the way we intend it
Those in () brackets imply only needed later in project.
This is propably horribly incomplete, but these are the 'roles' I can think of right now.
There are several tasks we need help with that does not involve programming, largely around the side of design which is an especially critical aspect right now. We are currently working off of an assumption of: 'Like Aurora unless said otherwise' I suppose though.
EDIT:
I threw together this: http://pulsar4x.pentarch.org/wiki/index.php?title=Source_Code
I would like to get the basic solution and project structure up asap. I dunno when we'll be able to get the devs together for a chat, but I don't think too many disagree with my proposed structure here. MrBear suggested splitting the Lib project into multiple projects, but I agree with clement in that others can be extracted later. Test and installer projects are possible 3rd and 4th projects that will happen, but those won't affect the structure of the basic gameplay.
I'm considering doing a quick WPF UI as a side-project on the repo simply because I find it faster to prototype with it as output for testing mechanics. Since we want cross-platform compatibility though Winforms will remain the main supported UI.
-
Like Clement I have Skype but not Teamspeak, can set it up if thats what we want to use tho.
-
I'd personally rather use skype than teamspeak, but will go with whatever's chosen.
-
I'm hearing a lot of everyone saying they have and are willing to use Skype and noone against. Best way to do this might be to send Skype usernames to a single person who adds them, as we join in conference calls and such we'll get access to everyone else's. Not sure whether sublight wants to take care of this or we should appoint a communications officer? Or just post skype usernames here
As an aside, github is setup and working fine here, I can download and push changes fine. This pretty much solves any issues I had about it before.
-
Skype it will be.
I guess organizing communication is a Project Head responsibility. I can do that.
Time: Also send when you are available. Best times for me is this hour and 12 hours from now: but I'm flexible.
I can wear a 2nd hat besides Project Head. Simulation Dev and/or Ships and Technology Designer are of greatest interest to me.
-
Since I'm distracted today, new conversation point... units of measurement.
First of all, metric. I will veto anyone who suggests anything different.
Then for other stuff...
Stars in Solar Masses, where our Sun is 1.0
Planets in Earth Masses, where Earth is 1.0
Orbits or inter-planetary distances in AU, where earth is 1.0 AU from the Sun
Luminosity in solar luminosity units, where the sun is 1.0 L
Masses not planetary-sized usually displayed in tonnes. Not tons... the 1000kg tonne or metric ton.
Time? Seconds, Minutes, hours, days and years, even on planets where 1 day != 1 earth day, we will gnerally use Earth days. Not entirely sure about months due to its variable nature, but I'm sure we can work out something.
Pattern? Intentional. This is to give players proper perspective compared to the known, aka Earth. Since the default game will anyway play as humans from Earth (I assume this and see no reason not?) this will also be accurate ingame. For other races... since we are doing the MVVM thing it might be possible to have each player allowed custom units of measurements, an alien race's umbarg might be distance from their planet to their sun, but has little use beyond RP so a later added feature if anything I think.
-
For me, as far as roles go, I can fill in on pretty much any position but would probably be of most use in the game engine. I have worked in every part of the stack from database access up to the UI and most of my time right now at work is spent on architecture/design and performance tuning of different tiers.
I agree with Antagonist that getting some design documents together would be a good idea. Even if they are basic and just define the sections that are going to be consistent with Aurora. If there are parts of the Aurora that we want to tweak or change we should definitely hash those out early on so we know what effects they will have on other systems.
@Antagonist I have my code conversion of Accrete broken out in a separate repository, I will try to clean it up and get it posted on Github in the next day or two and then we can talk about it and the functionality you were working on.
If anyone wants to discuss any of this via chat, just message me and I will send you my chat info. I can generally chat at anytime of the day unless I am in a meeting I could not avoid. I live in Atlanta, GA which is Eastern Time Zone (UTC-5).
-
I'd be tempted to either skip months altogether as a time unit (especially since they require a moon to make sense on a planet) or to call a month 30 earth days as a defacto standard.
-
Since I'm distracted today, new conversation point... units of measurement.
First of all, metric. I will veto anyone who suggests anything different.
Then for other stuff...
Stars in Solar Masses, where our Sun is 1.0
Planets in Earth Masses, where Earth is 1.0
Orbits or inter-planetary distances in AU, where earth is 1.0 AU from the Sun
Luminosity in solar luminosity units, where the sun is 1.0 L
Masses not planetary-sized usually displayed in tonnes. Not tons... the 1000kg tonne or metric ton.
Time? Seconds, Minutes, hours, days and years, even on planets where 1 day != 1 earth day, we will gnerally use Earth days. Not entirely sure about months due to its variable nature, but I'm sure we can work out something.
Pattern? Intentional. This is to give players proper perspective compared to the known, aka Earth. Since the default game will anyway play as humans from Earth (I assume this and see no reason not?) this will also be accurate ingame. For other races... since we are doing the MVVM thing it might be possible to have each player allowed custom units of measurements, an alien race's umbarg might be distance from their planet to their sun, but has little use beyond RP so a later added feature if anything I think.
For time I think just go with Seconds, Minutes, Hours, Days, Months, and Years based on Earth. That will match with the players' internal references. That also makes it very easy to track in game how much time has passed. Also, if there is a new settlement on a planet with a 16 hour day or a 20 day month, that will not change the amount of time it takes run the production cycle or any of the other things in game that are based on time.
-
If you wanna get added to the Skype chat room we have made, message me or sublight your Skype info, or add me to skype directly (l.skyfire). Well, sublight is primary communications but he's working till... 10:30PM GMT if I worked that out right in my head. This is tentatively also the time when we can start with 'official' discussion if most ppl can make it then, though you can join the room and chat beforehand too.
-
As I'm finding in my skirmish simulation, changing the time intervals "breaks" a lot of stuff, so that is something to bear in mind if you want to change the time interval model around.
-
As I'm finding in my skirmish simulation, changing the time intervals "breaks" a lot of stuff, so that is something to bear in mind if you want to change the time interval model around.
I’m curious, what exactly broke when you changed the time interval?
It’s possible to code things like that to handle a variety of intervals without breaking.
-
Yes, all that is required is reworking the appropriate game mechanics, or just accepting a new situation. capacitor recharge rates work differently with a smaller time resolution, which makes larger guns somewhat quicker to recharge. movement is altered by a shorter time interval as another example. aurora does not resolve distances smaller than 10km I think, and any ship moving faster than 2 km/s can clear that. with a 20th of a second interval all of the sudden any ship not moving atleast 200 km/s won't be able to move without some specialized handling. My solution thus far is to resolve distances down to 1km, and again do said specialized handling.
Another issue is lightspeed. lasers will travel the appropriate distance for a 5 second interval under all situation(except max tech pdc lasers, who get to travel a little faster), but with a smaller time interval how should that be handled? just FTL lasers? laser "packets"?
its not a show stopping issue, but it brings some things up.
-
Yes, all that is required is reworking the appropriate game mechanics, or just accepting a new situation. capacitor recharge rates work differently with a smaller time resolution, which makes larger guns somewhat quicker to recharge. movement is altered by a shorter time interval as another example.
In a real time game we get around issues like this using Frame-Independent-Movement. Basically we use the time taken to render the last frame (Commonly called delta time) to adjust thing like movement, recharge times etc.
As an example for a take a player who moves at 10m/s and a delta time of 0. 01667, we would calculate his movement using:
PlayerSpeed = PlayerSpeedPerSecond * DeltaTime
PlayerSpeed = 10 * 0. 01667;
PlayerSpeed = 0. 1667m/s - We only move 16. 67cm that frame.
This scale up for any size delta time.
Applying this to an Aurora Like game, for a ship that moves 1000km/s and an interval of 5 seconds:
ShipSpeed = ShipSpeedPerSecond * Interval
ShipSpeed = 1000 * 5
ShipSpeed = 5000km/s.
Or for Power Recharge rate of 5 Power per Second, and an interval of 5 Seconds:
PowerRecharged = RechageRate * Interval
PowerRecharged = 5 * 5
PowerRecharged = 25.
The thing is to pick one single time unit as the standard unit (in this case a second) and them measure everything in that, m/s, Km/s, Power Recharge per Second, etc. This allows us to use a scalar (delta time) to adjust it.
The one problem with the Interval method is that with larger interval you won’t get compounding affects you get with smaller intervals around acceleration and the like. This could be solved by either always processing in the smallest possible increment (impractical?) or by using formulas like those used when calculating compound interest in finance when using anything larger than the minimum interval.
aurora does not resolve distances smaller than 10km I think, and any ship moving faster than 2 km/s can clear that. with a 20th of a second interval all of the sudden any ship not moving atleast 200 km/s won't be able to move without some specialized handling. My solution thus far is to resolve distances down to 1km, and again do said specialized handling.
As you say these resolution/collision issues need to be resolved using special cases, however if you code the game right this shouldn’t be too had either. A couple of ideas I’ve used include:
Ray Casting: Extend a ray (line) out in front of the ship in the direction of travel and see if this ray intersects any other objects (or any 10km square containing an object). If it does, see if the distance to that object is less then how far you will be moving for this interval, if the distance is smaller than process a collision, else just move. This can all be done using vector maths, a good physics library will have most of this already implemented.
Spatial Partitioning: This can allow us to resolve down to much smaller distances, but only when actually required. First we divide a system up into a grid of squares, say 100,000km to start, if 2 (or more) objects for which we need to process a collision are in the same grid square (say a ship and a missile) then we divide up the the square into even smaller squares, say 1000km and check again. We can keep doing this until we get down to a scale where we can say for certain what is going on. In your case you could use a similar concept to this, resolve down to 10km normally, if things are happening inside a 10km square area then resolve down further, keep going down until things make sense.
Another issue is lightspeed. lasers will travel the appropriate distance for a 5 second interval under all situation(except max tech pdc lasers, who get to travel a little faster), but with a smaller time interval how should that be handled? just FTL lasers? laser "packets"?
Light is probably the hardest thing to work with because it moves so dam fast! One way to handle it is to treat a beam weapon as a ray (as describe above), if that ray collides with ANY object in a minimum increment then a collision is assumed to occur. If it could have collided with multiple objects then whichever is closer is the one that gets hit.
It’s all possible it’s just a matter of deciding at what point it feels “real” enough that we can stop processing to smaller resolutions, that’s what play testing is for, and if we can achieve “real” given the limits of the processing power available.
/endrant
Regarding Pulsar4x, are we going to change the way the increment work, maybe go real time + pausing?
Also RE months and Imperial Verses Metric, I say use Metric and Seconds/Minutes/Hours/Days/Years in the simulation and then add options for displaying Months and units in imperial into the UI later. The important thing is to keep what the engine/simulation uses internally consistent.
-
Myself and clement had a little chat on Skype about what 'realtime' Aurora implies. First of all, one thread a system seems a pretty safe bet. Systems don't really interact with each other all that much so it minimizes race conditions. Usually between player and AI there should be at least around 4 systems eventually, so enough for multithreading to be useful even if the work per thread isn't exactly balanced, but it helps.
The comparison with XCOM worldscape is reasonably apt. You either click > which is around 1 hour per real second, >> which is around 1 day per real second, >>> which is around a week per real second, etc. Or you can pause and review your blueprints and design new ships and assign orders. This will work much like 'autoturn' on current Aurora, just with smaller subintervals and consistent real:ingame time. However, in order to do this properly so that the speed is same for fast PCs and for slow ones you are gonna have to work off some delta, such as timesincelastupdate. Basically frame independant approach used for rendering and physics in most modern game. Faster PCs will naturally have smaller deltas and more accurate simulations while slow PCs will have coarser. Ideally both coarse and fine subintervals should both result in same end, but will have to work on that.
The biggest bottleneck of base Aurora is basically its tendency to read and write from the Access database every update. Just by using an ORM and keeping data structures in memory we gain an incredible performance benefit and should be able to do much more than base Aurora can.
Combat though... combat. 1 day subintervals might be alright for economy, where little is different compared to hourly subintervals, but combat might require 1000s of updates in the span of an ingame hour. Whether in a visible system or not.
There is always going to be some interval in combat that if it becomes larger then things will mess up... Missiles will miss targets, ships will go the wrong way (towards the unupdated target), damage control and damage might happen differently... The capacitor recharge thing sounds weird and could be a bug. The compound formula mentioned by SnopyDogy might be the solution, though not sure if that's what is actually happening.
Ideally we might have some sort of event driven system for updates on combat out of system... if a ship is coasting into 100mil km range before it can release its missile payload it won't need updates till either it reaches that range or it gets hit. If it isn't getting targetted then only thing to worry about is range. Say it needs 10 mins to reach its target we can delay updates for 5mins, then update position and recalculate when next update is (since target may have moved closer). If it is targetted or something is intercepting it you'd need updates more often. Or if player is actually watching then we need everything updating smoothly every interval, positions and all, just so player doesn't see jumping ships. Largely I'm looking for optimizations we can apply to out of system combat between AI opponents, but keep the results of the combat the same.
As said above, Pulsar4X has a natural massive performance advantage over Aurora just because of the ORM, aka keep stuff in memory rather than writing to db every interval. We should take advantage of that. Steve I believe in one of his posts mentioned wanting to go down to 1s minimum interval and I propose to do the same. We're not working off Aurora source code here, which is a disadvantage, but it allows us to redesign some of the basic systems in a better way than they are currently done. This includes the timing systems.
Making minimum interval 1 second naturally increases the issues with lightspeed weapons. Steve is currently using some packet system for his rail weapons in Newtownian. We can do the same... or we can break physics and have beam weapons instantly hit even if the target is several light seconds away. I don't think this breaks much to be honest, so long as we work in velocity and acceleration into hit chance. Would simplify a lot, and often firing rate matters more in combat than whether the damage is done now or in 5s.
Biggest thing we need to decide is whether to go Newtownian or to go transNewtownian. The former is MUCH harder to program, the latter simpler. Perhaps we can go the latter, then switch to former in a later iteration. Largely I think it is up to those willing to actually code it, aka what do they feel they can accomplish? Intercepting an object with another object, plotting courses and so using Newtownian physics is HARD. Moreso when that other object also has its own ideas.
-
I was thinking along the lines of the XCOM style system myself. I like the idea of playing Aurora (especially the battles) in real time or faster. I think the game would flow better that way. If you can pause any time you like then this isn’t a huge break from how the game is played now anyway.
I know other games have systems where you can increase the rate time moves in the game world and have it drop back (or even pause) automatically when required. I understand most of them are artificially increasing Delta time. For example:
Speed *deltatime * TimeIncrement
100m/s * 0. 1 seconds * 1 (real-time) = 10m/s this frame
100m/s * 0. 1 seconds * 10 (10x real-time) = 100m/s this frame.
At faster speeds there will be a lot of “looking ahead” in an attempt to predict what is going to happen and when to move to smaller increment (slow down). This is where thing like Ray casting come in useful (see above post).
It might be a good idea to use a 3rd part physics library to take the pain out of setting up the Physics for combat and the like. A quick Google search for c# physics engines showed up:
hxxp: code. google. com/p/physics2d/
hxxp: jitter-physics. com/wordpress/
hxxp: henge3d. codeplex. com/
hxxp: farseerphysics. codeplex. com/
hxxp: code. google. com/p/bulletsharp/
The Last one looks like a good bet, it’s a c# wrapper for the Bullet Physics library (one of the best).
Regarding light speed weapons, I have heard that many AAA title games start out with a physics model MUCH closer to the real world than what ends up shipping, the pull out or simplify anything that gets in the road of gameplay. I don’t have any problem with doing the same for light speed weapons, as long as it make sense to the player and is fun.
A similar thing can be done for AI battles; if the player can’t see them then do we really need to simulate it exactly? We could cheat and not process exactly what happens, e. g. Missile fired, wait until enough time has passed, then just assume it hits and process detonation, no movement, no collision checks, just an estimate of flight time and POW it there (think Quick Battle in Total War where the computer works out the result of a battle in a few seconds). We can do the same for path finding, if the player can’t ever see the ship do we need to track exactly where it’s going, we could just get an estimate of time and then have it appear at its destination after this amount of time has passed.
At collage a few months back we had a talk from a senior (20+ Years’ experience) producer from Sony Portable Games division. He said the best advice he could give for developing a game is to get it playable ASAP. Once you can play it you can get idea of what works and what doesn’t, then you can iterate and improve things. The faster you get to something that can be played, no matter how bad, the better the end product.
I think this is good advice for us. I don’t mean that we should rush, but the sooner we have something that we can play the sooner we can find out what does and doesn’t work. I think it would also help keep everyone engaged with the project over the long term, especially those who can’t contribute to the code.
-
Threw up a basic solution and project structure on github.
Created in VS 2010 Pro.
2 projects, Pulsar4X.WinForms and Pulsar4X.Lib
Default namespace for both is just Pulsar4X to keep down needed using statements
Lib seems to load fine in mono-dev, WinForms one sublight had some issues with. Anyone who knows mono compatibility who can take a look at it?
Next step might be adding log4Net as an external reference and try get that working crossplatform, as well as start with the utility and constants classes, and working on the stargen, something I discussed with clement.
Can throw up some basic entities like Planet and Star as well, but these may change with requirements of ORM, which we still havn't picked. Right now between LINQtoSQL and Dapper.
Simulation devwork is likely dependant on basic entities, game design and all, but I suppose we can lay down some basic multithreaded support solong.
UI I'm not touching, but can do with some love.
Err... what else... plenty that can be done, but a lot we need the design and other decisions for first.
If you have opinions, hop on Skype with us.
-
Okay, so I see log4net has a gazillion dlls and you need to pick the correct one (mono, .net 4.0, 3.5, etc) to link to. Between this and the whole mono and alternative IDEs thing I am now rethinking the approach to solution and project files.
I would like to hear thoughts on using premake. For those not in the know, this is basically something that generates .sln and .csproj files. We can have it do stuff like 'If linux, use lib x, if windows, use y' or 'mono reference these libraries, .net these', all without the mess of a mono project and .net project and attempting to keep it all synced.
-
And done.
premake now generated .sln and .csproj files that compile and work okay on my PC. They may need some extra references added as we add code however.
Just grab source from repo and run premake4.exe in the base directory to set it up. Try not to sync the generated solution and project files back to the repo tho till we have confirmed this works.
-
"As you say these resolution/collision issues" - Aurora doesn't really do collision detection, and pulsar probably shouldn't worry about it either, other than for hyperlimits and sensors, I experimented with a quad tree, but with just 1 object its a waste, and sensors are basically going to be dynamic(and wierd due to having multiple detection radii) so no reason to do anything there. We'll see how that plays out. The biggest gain item that I think I can do is to have lookup tables instead of calculating various things. thus far sensors and FCs have lookup tables in my code for detection/accuracy at distance functions.
XCOM is little different from aurora as is so that won't be an issue. at first when I heard XCOM I thought you meant the turn based battle, not the geoscape.
"The biggest bottleneck of base Aurora is basically its tendency to read and write from the Access database every update. Just by using an ORM and keeping data structures in memory we gain an incredible performance benefit and should be able to do much more than base Aurora can." - Yea, my skirmish sim is basically going to not have a database. Its being done in c just to be contrary but I can port over relevant code when needed, such as the component stuff I've worked out. The other reason for what I'm doing is to derive the appropriate formulas for how things work, and I have most it it done right now, currently grappling with armor.
-
Here is a screenshot from the quadtree example I cooked up. The red and blue blocks know that they are inside/outside the hyperlimit respectively. The green and yellow ones are close enough to the boundary that they have to calculate it. unfortunately this didn't offer savings over just calculating the distance, again because it was only 1 collision being tested against. In the simulation all of the blocks are moving between the white block bases at random, and traveling at 10x speed when outside of the hyperlimit.
-
Defintely looks interesting, not just your simulations which is essentially documenting and testing the components and ships and tech and combat systems, but also your experiments with quadtrees which as I understand it you say is not worth it.
So long as your datafiles are clear and readable it should not be a problem porting those over when needed, and your with lookup tables and formulas definitely interest me in respect to the combat and simulation modules of Pulsar4X.
Its just gonna take a while I think before Pulsar4X has matured enough to take advantage of your work in this regard, since we need to implement the functionality in the UI to manipulate fleets and ships and components before we can really have playable spaceflight or battles. Perhaps we can for testing purposes implement something to allow random automated battles sooner than otherwise, but will have to see how things go.
There has been mention in the Ideas forum about decoupling emitters and detectors with sensors that I am somewhat keen on, though again it would likely increase the complexity of a proper working sensor system.
And yes, strictly the XCOM geoscape 'realtime' kinda system, wish we had a better illustrative example so its not confused with the battlescape time system.
The simulations you are doing, is it using newtownian or transnewtownian physics? Also, how does your subimpulse vary? Minimum step of 5s like base Aurora or less?
-
I'm aiming for 5.6 rules, the above image doesn't have components implemented as yet, those are just blocks moving at 1x speed and 10x speed. and my sub pulses will essentially be real time, once I get there.
-
And done.
premake now generated .sln and .csproj files that compile and work okay on my PC. They may need some extra references added as we add code however.
Just grab source from repo and run premake4.exe in the base directory to set it up. Try not to sync the generated solution and project files back to the repo tho till we have confirmed this works.
Works for me, I can run premake.exe and compile the resulting projects.
-
I still need to get premake properly working for sublight on his Mac/Mono setup, but for the majority on windows the current setup should work fine.
I want to get the repository to a point now where people can actually start contributing, seeing my name over and over on the repo. There are still some decisions that need to be made regarding ORM or so, but for most that won't affect anything.
Some things still rely on design decisions we need to make, but for basic UI and game logic we can work with what we have decided so far. See about getting something running. So for every dev that has offered: What do you want to work on and what do you need done before you can start.
EDIT: Best way to get involved is also to join us on skype. Just add me (l.skyfire) and I'll add you to the room.
-
"As you say these resolution/collision issues" - Aurora doesn't really do collision detection, and pulsar probably shouldn't worry about it either, other than for hyperlimits and sensors, I experimented with a quad tree, but with just 1 object its a waste, and sensors are basically going to be dynamic(and wierd due to having multiple detection radii) so no reason to do anything there. We'll see how that plays out. The biggest gain item that I think I can do is to have lookup tables instead of calculating various things. thus far sensors and FCs have lookup tables in my code for detection/accuracy at distance functions.
By Collision I mean testing for a condition that requires 2 different objects to interact in some way. You example of a ship and a stars hyper limit is a good one. These things happen all the time in Aurora and handling it right, especially across large increments, is important. For the sensors have you thought about marking the quads in the quad tree with a marker to say "if in this quad and above this mass, test to see if in range of this ships sensors"? Sorta like combining the lookup tables with your quad tree.
BTW I would love to have a look at the code for your skirmish sim if you’re willing to share.
-
Sure, and most of it will be stuff that I'll want to convert to c# and upload anyway, but I'll wait for milestones for releases like that.
-
Nathan_: I won't be the one doing it, but I advise that when we get to laying the groundwork for the simulation framework you have a nice long chat with the devs that will be responsible. On design and implementation and algorithms. Best case you all learn something and might help eventual porting if we choose to port something.
That said, your work so far looks good.
-
I've got all the code written for components atleast, so am testing some things. I've taken the hyperEx code and put sensors and signatures in, and have these two images that are mostly the same. the ships are now yellow boxes, and above them are 3 boxes colored red, green, and blue of varying brightness depending on how many other ships have spotted this one on thermal, active, and em respectively. the signatures are determined randomly for each ship, but each ship's sensor is the same basic size 5 active,thermal and em sensors. And lastly there are 500 ships running around.
the FPS change is the result of this sliver of code, with the 1st image using the lookup tables that I mentioned earlier, and the second calculating everything on the fly:
int newRange,thm,em,newRange2,thm2,em2;
if(swapQT == 1)
{
newRange = 25000000 * pow( ( (double)(ships[ loop2 ].TCS - 1 ) / 100.0 ) , 2.0 );
newRange2 = 25000000 * pow( ( (double)(ships[ loop ].TCS - 1 ) / 100.0 ) , 2.0 );
thm = calcUnknownSignature(ships[loop].thermal,(ships[ loop2 ].thermalS - 1));
thm2 = calcUnknownSignature(ships[loop2].thermal,(ships[ loop ].thermalS - 1));
em = calcUnknownSignature(ships[loop].EM,( ships[ loop2 ].EMS - 1 ));
em2 = calcUnknownSignature(ships[loop2].EM,( ships[ loop ].EMS - 1 ));
}
else
{
newRange = ships[loop].active->lookUpST[ (ships[ loop2 ].TCS - 1) ];
newRange2 = ships[loop2].active->lookUpST[ (ships[ loop ].TCS - 1) ];
thm = ships[loop].thermal->lookUpT[ (ships[ loop2 ].thermalS - 1) ];
thm2 = ships[loop2].thermal->lookUpT[ (ships[ loop ].thermalS - 1) ];
em = ships[loop].EM->lookUpT[ ( ships[ loop2 ].EMS - 1 ) ];
em2 = ships[loop2].EM->lookUpT[ ( ships[ loop ].EMS - 1 ) ];
}
These things happen all the time in Aurora and handling it right, especially across large increments, is important. For the sensors have you thought about marking the quads in the quad tree with a marker to say "if in this quad and above this mass, test to see if in range of this ships sensors"? Sorta like combining the lookup tables with your quad tree.
I had thought about that, but quadTrees really only work best with static unchangeable terrain. since sensors are so weird, can move around, and can be destroyed at will, the overhead from the quad tree would probably eat any gain from it.
-
Just to let everyone know, just cos its quiet here on forums doesn't mean nothing is happening.
We're pretty active on Skype and getting plenty work done.
What we're hoping to do soon is to release an 'alpha' version which basically includes the F9 screen and the system view screen. Since the system view is done in OpenGL we'd like as many people possible to test it on a variety of hardware so that we can get an idea on how well supported our code is on the platforms that players will be using.
This will showcase our star and planetary system generation, though it will be an ongoing effort to optimize it.
If anyone is interesting in taking part in the skype discussions, either as an interested party or as someone willing to contribute, just send me or sublight a message with your skype id.
Just keep an eye on this space!
-
I am for sure in for a testing pig :)
1440x900 screen resolution on a notebook is not that standard. . . but then again. . . maybe it is :p
Looking forward!
-
Joe, if you want to start testing early contact antagonist or sublight and join the skype conversation. I could really use someone to test the OpenGL stuff more.
-
Intergalactic message away. . .
Unfortunately I am not well suited for skype conversations, as they are not allowed at work and when I am at home, I tend to my 1. 5 year-old twin ladies and my wife most of the time :)
-
Pitty You can't get on Skype Joe, Still the offers still out there if anyone else wants to jump in. We could really use someone for testing Mono Compatablilty in Linux in addition to the OpenGL stuff.
-
Might as well actually post this here.
If you wanna see what we're up to but don't want to join on skype, you can download and compile the source yourself. It's very easy. We would especially like this to test whether the OpenGL works properly on a wide range of hardware. We'll release an alpha once we're happy with the features we're adding, but if you can't wait you can check out our in-progress build.
Assuming windows, you'll need Visual Studio 2010. Express will do: http://www.microsoft.com/visualstudio/en-us/products/2010-editions/express
Then you need github for windows: http://windows.github.com/
Head to this site: https://github.com/Pulsar4xDevs/Pulsar4x
and click on clone in windows.
This should place a copy of the source in the Documents\Github\Pulsar4x directory by default I think. Double click premake4.exe to generate the solution and project files, then double click on the resultant .sln.
Build and run from the menu and you should see our splash screen appear!
If there are errors, particularly ones relating to OpenGL, please alert us. There should be a .log next to your exe which might contain essential information on the error. I'm thinking we might need a bug report topic, but will see how this goes.
If you are NOT on windows then we would especially like your help to get Pulsar4X working on other platforms. We are for the most part windows devs so that is what we have been focusing on. All libraries we use are mono-compatible, we just need to get them linking correctly. No real coding skills needed just some knowledge of your platform, command line, how to get around on it, install packages and knowledge of where the libraries are installed on your platform. If so, please let us know and preferably join us on skype!
EDIT:
I added a new thread for all this.
-
can I build on mac?
-
Technically yes.
Its not working correctly yet, sublight is on Mac himself and it should be working at some point.
If you're willing to offer some help on that front let us know.
-
I'll go ahead and get on the skype discussion. I have still been working on the combat sim, but its fairly involving as it turns out.
-
For graphics, if you need them you might want to check out opengameart.org
-
Technically yes.
Its not working correctly yet, sublight is on Mac himself and it should be working at some point.
If you're willing to offer some help on that front let us know.
no I can only follow order and launch script I can't really resolve anything outside things I know (java/objective-c)
-
Just chiming in - was able to build the "game" and launch it on a different notebook than mine and aside from two OpenGL issues (me and Antagonist both suspect PC drivers, not the code itself) the thing runs just fine.
Resizable and scrollable throughout, the System Info and System map windows show the preinserted values and buttons click as they should. . . So no issues I see so far :)
Will try the build on my own notebook during the weekend just to see if I do get any OpenGL issues.
-
The repository has moved to a new organisation, Pulsar4xDevs.
This means that the repo link is now https://github.com/Pulsar4xDevs/Pulsar4x
It appears the windows client is smart enough to automagically point to the new one, so no worries if you have already cloned it. If you have not yet, please use the new repository link.
@LoSboccacc:
We'll let you know once Mac version is working. We have resolved most of the issues, but we can definitely do with another tester on the mac side to make sure it works for everyone when we release.
@joe:
Lemme know if updating drivers works any. Right now we assume OpenGL 2.x minimum, which is basically DirectX 9 compatible card. If there are a lot of people who want to play Pulsar on PCs either with really crap inbuilt or else with really old GPUs, we CAN add in OpenGL 1.x support. But would prefer not to have to at this stage.
-
Does the mac have any equivalent to the SSE instructions? thats my current method for doing square roots, but I've got some others if that comes up.
Heres the function in question:
void calcDistance()
{
//check if less than 4 distances to be calculated
//if no then load and calc distances for 4
for( int loop = 0; loop < agentNum; loop++ ) //for each agent
{
for( int loop2 = loop; loop2 < agentNum; loop2+=4) //calc 4 at a time
{
if( agentNum - loop2 < 4 )
{
__declspec(align(16)) float xData[4] = { 0.0 };
for( int loop3 = 0; loop3 < (agentNum - loop2); loop3++)
xData[ loop3 ] = ships[ loop ].position.x - ships[ loop2 + loop3 ].position.x;
__declspec(align(16)) float yData[4] = { 0.0 };
for( int loop3 = 0; loop3 < (agentNum - loop2); loop3++)
yData[ loop3 ] = ships[ loop ].position.y - ships[ loop2 + loop3 ].position.y;
__declspec(align(16)) float zData[4];
__asm
{
movaps xmm0, [xData + 0x00]
movaps xmm1, [yData + 0x00]
mulps xmm0, xmm0
mulps xmm1, xmm1
addps xmm0, xmm1
sqrtps xmm0, xmm0
movaps [zData + 0x00], xmm0
}
for( int loop3 = 0; loop3 < (agentNum - loop2); loop3++)
{
ships[ loop ].dist[ loop2 + loop3 ] = zData[ loop3 ];
ships[ loop2 + loop3 ].dist[ loop ] = zData[ loop3 ];
}
}
else
{
__declspec(align(16)) float xData[4];
xData[0] = ships[ loop ].position.x - ships[ loop2 + 0 ].position.x;
xData[1] = ships[ loop ].position.x - ships[ loop2 + 1 ].position.x;
xData[2] = ships[ loop ].position.x - ships[ loop2 + 2 ].position.x;
xData[3] = ships[ loop ].position.x - ships[ loop2 + 3 ].position.x;
__declspec(align(16)) float yData[4];
yData[0] = ships[ loop ].position.y - ships[ loop2 + 0 ].position.y;
yData[1] = ships[ loop ].position.y - ships[ loop2 + 1 ].position.y;
yData[2] = ships[ loop ].position.y - ships[ loop2 + 2 ].position.y;
yData[3] = ships[ loop ].position.y - ships[ loop2 + 3 ].position.y;
__declspec(align(16)) float zData[4];
__asm
{
movaps xmm0, [xData + 0x00]
movaps xmm1, [yData + 0x00]
mulps xmm0, xmm0
mulps xmm1, xmm1
addps xmm0, xmm1
sqrtps xmm0, xmm0
movaps [zData + 0x00], xmm0
}
ships[ loop ].dist[ loop2 + 0 ] = zData[ 0 ];
ships[ loop ].dist[ loop2 + 1 ] = zData[ 1 ];
ships[ loop ].dist[ loop2 + 2 ] = zData[ 2 ];
ships[ loop ].dist[ loop2 + 3 ] = zData[ 3 ];
ships[ loop2 + 0 ].dist[ loop ] = zData[ 0 ];
ships[ loop2 + 1 ].dist[ loop ] = zData[ 1 ];
ships[ loop2 + 2 ].dist[ loop ] = zData[ 2 ];
ships[ loop2 + 3 ].dist[ loop ] = zData[ 3 ];
}
}
}
}
-
Does the mac have any equivalent to the SSE instructions?
yes, they're intel now. I believe you could have some problem with the asm syntax, but I see that at least you're declaring everything16-bit aligned, which is the main problem when porting asm to osx
btw, why asm and not something like http://www.agner.org/optimize/vectorclass.pdf (simd for the lazy)?
-
The example of how to do it that way was 1 page, and I was looking for something quick. also I wanted to experiment with the SSE stuff in any event.
-
For the record the log file output bu Pulsar includes information like Video Card, OpeGL version detected, GLSL (Shader) version detected, etc. It should be just after the stargen stuff. If you are having OpenGL Problems you can check there to see if Pulsar can find a compatible version of openGL (anthing higher than 2.1, not sure if 2.0 works as it hasn't been tested).
-
We've started to use the github issue tracker. Just for reference, this is for bugs and assistance requests. If you gonna work on something and complete it yourself there is no need for a ticket. On the other hand if there is something you won't get to in a while and might be suitable for a newcomer or bored dev to tackle, please submit a ticket.
We might also use this for tracking milestones, but lets see how it goes first.
-
Alright, with the release of alpha 1 we need to start thinking about what we want for alpha 2.
Note that none of this is authoritativeness. We are a loose collection of devs. You want to put in something, put in something. I'm only raising this topic for discussion on what would be cool to show off next release.
First thing I'm thinking is the actual time controls. Not just will planets moving smoothly around their orbits look awesome, time controls are required for economies, ships, and actually any gameplay element whatsoever.
Second what would be cool is selectable planets in the system map, summary of planet on the left, buttons or double clicking taking them to the planet in F9, or to the economy screen.
On the backend, I'd like to improve the stargen a little. Add comets, find a nice way to get asteroid belts working too. And clean up orbits so we don't get AS MUCH crossing as we do now, but keep crossing possible.
Trying to get mac and linux builds working has been educational and... its not easy. Something is especially seriously wrong with mac's mono, but we're on it. Hope to get that working properly for next release.
Otherwise I like and I'm impressed with what we have. This is a hobby, all devs volunteer their time, and we have made quite nice progress so far. Great job all!
-
I've finally finished with the sensor model.
Sensor components themselves store a lookup table of values, where the signature of any particular ship just needs to be plugged in to get the appropriate value.
int getActiveDetectionRange(activeSensor *sensor, int TCS, int MSP)
{
//limits of the array
if( TCS > 499 || TCS < 0 )
{
return -1;
}
int range;
if( TCS != 0 )//ships
{
/*int shipTCS = TCS - 1;
if( shipTCS > 499 )
shipTCS = 499;*/
range = sensor->lookUpST[ TCS ];
}
else //missiles
{
range = sensor->lookUpMT[ MSP ];
}
return range;
}
Next up are ships, which store their signatures, a pointer to a sorted linked list of all 3 detection values, and an indicator for whether or not a player has IDed this ship this tick:
//Detection related statistics
int TCS; //Total Cross Section for active scanners. modified by cloaks
int tSig; //thermal signature of ship. modified by thermal reduction
int maxTSig; //maximum thermal signature of the ship.
int eSig; //EM signature of ship. no way to reduce this, shields and actives are always detected.
//which players have detected this ship and how.
unsigned int thermalDet[32];
unsigned int EMDet[32];
unsigned int activeDet[32];
//this ship's placement in the linked list of thermal/em/TCS lists.
sortList *thermal;
sortList *EM;
sortList *active;
At the taskforce level I have a distance table, a pointer to each of the best passive sensors, an active sensor que for which active sensors are on and working, and a lookuptable that addresses the active sensor que, which can then be used to access that particular sensor's lookup table, and finally the heads and tails of each of the sorted linked lists of all the ships in this taskforce, from least to greatest.
if( TG->activeCount != 0 )
{
for( int loop = 0; loop < 500; loop++ )
{
//TG->tfLookUpST is different from ->lookUpST. the first stores an index to the active que, the second
//stores a range value at that particular resolution. In effect tfLookUpST points you at the best sensor to
//look for that resolution value with its lookUpST.
if( TG->activeQue[ TG->activeCount ]->lookUpST[ loop ] > TG->activeQue[ TG->tfLookUpST[ loop ] ]->lookUpST[ loop ] ) //<<<
{
TG->tfLookUpST[ loop ] = TG->activeCount;
}
}
for( int loop = 0; loop < 15; loop++ )
{
if( TG->activeQue[ TG->activeCount ]->lookUpMT[ loop ] > TG->activeQue[ TG->tfLookUpMT[ loop ] ]->lookUpMT[ loop ] )
{
TG->tfLookUpMT[ loop ] = TG->activeCount;
}
}
}
at the player level I store global taskforce contacts, any taskforce that I no longer need to search because it has been detected, or cannot be detected(EM signature = 0)
Likewise I do a per player sensor sweep that touches on every taskforce in the global list, and every ship in that taskforce. First I check to see if none of the ships are detected(comparing best sensor vs biggest signature), then I check to see if they all are via the smallest signature against the appropriate sensor, and finally I run backwards through the linked list marking everything that is detected as detected
if( P->contactACTGlobal[ loop2 ] != tick && P->TFList[ loop ]->activeCount != 0 )
{
noDet = 0;
allDet = 0;
shipSig = tfListGlobal[ loop2 ]->tfShipList[ tfListGlobal[ loop2 ]->aTail->index ]->TCS;
shipSig = shipSig - 1;
if( shipSig > 499 )
shipSig = 499;
shipDet = getActiveDetectionRange( P->TFList[ loop ]->activeQue[ P->TFList[ loop ]->tfLookUpST[ shipSig ] ], shipSig, 0);
//First check the biggest ship, which should be paired correspondingly to the longest ranged sensor
//If a smaller vessel would be detected at this range, then the biggest vessel must definitely be detected by that sensor or any better sensor
//barring a bug of course, but that doesn't detract from the logic
if( dist > shipDet ) //no detections
{
noDet = 1;
}
if( noDet == 0 )
{
shipSig = tfListGlobal[ loop2 ]->tfShipList[ tfListGlobal[ loop2 ]->aHead->index ]->TCS;
shipSig = shipSig - 1;
if( shipSig > 499 )
shipSig = 499;
shipDet = getActiveDetectionRange( P->TFList[ loop ]->activeQue[ P->TFList[ loop ]->tfLookUpST[ shipSig ] ], shipSig, 0);
if( dist <= shipDet ) //in this case the smallest ship is detected, which means that all larger ships must also be detected
{
allDet = 1; //either by this sensor, or by a better one
for( int loop3 = 0; loop3 < tfListGlobal[ loop2 ]->shipCount; loop3++ )
{
ship *enemyShip = tfListGlobal[ loop2 ]->tfShipList[ loop3 ];
enemyShip->activeDet[ P->ID ] = tick;
}
P->contactACTGlobal[ loop2 ] = tick; //all ships in this taskforce are detected
}
}//end if all detected
if( noDet == 0 && allDet == 0 ) //the larger ships are definitely detected, smaller ones may not be
{
sortList *aDet = tfListGlobal[ loop2 ]->aTail;
while( aDet != NULL )
{
ship *enemyShip = tfListGlobal[ loop2 ]->tfShipList[ aDet->index ];
if( enemyShip->activeDet[ P->ID ] != tick ) //this ship is already detected
{
shipSig = enemyShip->TCS;
shipSig = shipSig - 1;
if( shipSig > 499 )
shipSig = 499;
shipDet = getActiveDetectionRange( P->TFList[ loop ]->activeQue[ P->TFList[ loop ]->tfLookUpST[ shipSig ] ], shipSig, 0);
if( dist <= shipDet )
{
enemyShip->activeDet[ P->ID ] = tick;
}
else //once again, if this ship is not detected, but a smaller one is, then it would stand to reason that this ship would also be detected by that sensor.
{
break;
}
}
aDet = aDet->next;
}//end while
}//end if some detected
}//end if contactACTGlobal = tick
In this 1st picture, I have 32 players, 10 taskforces per player, and 7 ships per taskforce, I can do ~40fps with this happening every 16 ms.
http://imageshack.us/f/10/stress1h.jpg/
printing strings is horridly painful though.
http://imageshack.us/f/14/stress2e.jpg/
So I have working mechanics for engines and sensors now, though I'll probably scale back the player/taskforce count in the future.
-
Alright, found a few bugs, and have a better display of the sensors working, its not 40fps, now its down to 20fps, but still, this is with some 2240 ships.
The dark blue tfs are the ones who are only being spotted by the EM from their one sensor craft, the dark green craft have that, and a few of their ships being spotted by sensors. The light green craft are all lit up on actives, and the yellow one is spotted on thermal as well as active(as well as the one sensor craft).
-
This stuff is fantastic Nathanh_!
I don't see anything here that takes advantage of special instructions we dont have in C#, so the algorithm should be portable with a minimum of effort.
Performance seems pretty decent too even if its a situation that would preferably never actually occur in normal gameplay.
-
If someone has more experience with multicore stuff the EM/Thermal/ACT detection routines can be split up for even more gain, they all run independent of each other. I think I might make sensor data persist for a second or so, but that won't be an option for a time scheme like Aurora, or XCOM(both are fairly similar). Also DSTS would have to be integrated into that, missiles have to be done, and best sensors could be sorted globally, but I don't think there'd be any difficulty there.
-
I have multi-threading experience, but at the moment I'm tied up with making Pulsar Mac/Linux playable.
That reminds me: if anyone out there has free time and C# experience in Mac/Linux environments (especially mono) we could use another person working on solving cross-platform compatibility issues and testing.
-
If someone has more experience with multicore stuff the EM/Thermal/ACT detection routines can be split up for even more gain, they all run independent of each other. I think I might make sensor data persist for a second or so, but that won't be an option for a time scheme like Aurora, or XCOM(both are fairly similar). Also DSTS would have to be integrated into that, missiles have to be done, and best sensors could be sorted globally, but I don't think there'd be any difficulty there.
In c# it is very easy to split the detection routines up into multiple threads by using either Parallel or Task from the System.Threading.Tasks Namespace.
-
Hi, I'm also interested in helping developing Pulsar 4x. I have some experience in Phyton and Open GL, and I already developed a 3D map of the nearest star systems using Python and OpenGl, that I use while I play Aurora. It's still in an Alpha version, but you can rotate and zoom in and out. To add new star systems you still have to do it by hand. But I don't think it will be too much of a problem to use a plain text file with the coordinates and characteristics of the system, like the coordinates, size, type of star, or if the system belong to you or to another race. Another thing that can be added could be the number of planets and the mineral resources or infrastructure if the system has them.
I attach a pair of screenshots and the source code of the application in plain text. To run it you need Python 2. 6, Open Gl, and PyOpenGl.
Also, I did this in python and Open GL I don't know how hard or convenient can it be to port that to C#. But since this is just an ancillary application maybe It can be in Python.
Instructions:
To run the application download and install Python, Open GL and PyOpenGL.
To rotate the map just click with the left mousebutton and move the mouse around. To zoom in click with the middle mouse button and move the mouse, and to zoom out click with the left mousebutton and move the mouse.
-
Aw man. I was lurking this project with interest. Don't tell me it's gone dark? :)
-
Fear not, the project continues. 8)
A number of us, myself guiltily included, have taken unofficial leaves of absences for January: but most of the team has quietly continued to work in the background.
-
Ok, I've heard a few hits that maybe, just maybe, we should update more.
So, here we go:
Pulsar4x Winter Update
Q: Is the project dead?
A: No. We've just finished a lot of the easy stuff and have been quietly digging into the harder stuff.
Q: Who is employee of the month?
A: Nathan_, for exceptional work coding ship classes and components.
Q: What is the biggest change that has happened this winter?
A: Added Classic Trans-Newtonian Rules
Q: What have you, Sublight, personally done?
A: Newtonian Rules, Mac/Linux User Interface, Public Relations
I've put off work on Newtonian ship design until Nathan finishes to make sure both have similar code interfaces to allow.
The Mac user interface development has stalled while I brush up on Cairo vector graphics. The OpenTK C# port of OpenGL was discovered to have major incompatibility problems across different platforms, so for now Pulsar4X is more or less Windows Only.
Q: Any more thoughts about 3-D planet maps?
A: Yes. We've decided it won't happen. Or at least, that won't happen in the Alpha, first Beta, or anytime soon. What we might do is go for 1-D planet maps.
Aurora (and Pulsar) are mostly about a vast 3-D volume abstracted down to a 2-D surface. By the same logic, a 2-D surface ought to be abstracted down to a 1-D line, possibly looped into a circle. A line for planets is simple enough to program and offers a tremendous improvement in relative spatial positioning over the existing 0-D single points. It's not what we dreamed of, but 1-D planets are simple enough for our existing team of 4-6 part time volunteer programers to finish.
Expect to see the Spring Progress Report sometime in May.
-
As I said on the ideas thread, I have been lurking for a while, and I would like to try and get involved on this, so I would be grateful if I could be added to the list of users on github. My github username is interstellarshadow.
-
alright you should be added now, thanks to Antagonist I think. Do you use skype? we have a chat channel that we use for most things.
-
Alright, here's the comment to the Newtonian Combat:
I still haven't run through the battles involving the Rama cruisers, but my conclusions so far:
> Lasers are very good at point defense. Solid round rail-guns are very bad at point defense.
That's not really a surprise, I'd say.
> Having a higher acceleration may be of minimal use in strategic movement, but is a significant advantage when closing to direct fire weapon ranges.
> Direct fire weapon combat feels right.
That's great, and it looks like it from your descriptions.
> Missile combat mechanics feel like they need work.
Maybe, but maybe not. The problem with the missiles you used, as far as I can see, is that they're all only five tons - the equivalent of 2 MSPs of aurora. That means they're quite small. What could one do with quadrupling the size of missiles? Let's take, for example, the Killer ASM:
Killer Pumped-Laser ASM
Mass: 5 tons
Engine: 1x G.F. AMM-Standard Warhead: 135 kTon Nuke
Starting_Accell: 3.0 m/s DeltaV = 38.4 km/s, Reserve DV = 8.4 km/s
Max Burn Time: 2.8 hours
Proximity Detonation: 1.5k km Damage at PDR: 0 MJ/m^2
Lasing Rods: 1 Rod Output: 708 MJ Jitter 7 m/k km
Beam at PDR: 3m wide, 100 MJ/m^2
Quadrupling the size should leave us with something very much like this, probably even better:
Killer Mark II Pumped-Laser ASM
Mass: 20 tons
Engine: 4x G.F. AMM-Standard Warhead: 540 kTon Nuke
Starting_Accell: 3.0 m/s DeltaV = 38.4 km/s, Reserve DV = 8.4 km/s
Max Burn Time: 2.8 hours
Proximity Detonation: 1.5k km Damage at PDR: 0 MJ/m^2
Lasing Rods: 1 Rod Output: 2832 MJ Jitter 7 m/k km
Beam at PDR: 3m wide, 400 MJ/m^2
Still too easy to intercept, right? Well, that's not what I actually wanted. Instead, let's use the bigger size to increase the Proximity detonation range. In fact, to make this easier, let's quadruple it, too, leading to a proximity detonation range of 6k km:
Proximity Detonation: 6k km Damage at PDR: 0 MJ/m^2
Lasing Rods: 1 Rod Output: 2832 MJ Jitter 7 m/k km
Beam at PDR: 12m wide, 100 MJ/m^2
(I'm going with the idea that doubling the range doubles the beam width, too. I'm not sure about that, at the moment, and it changes quite a bit)
That would mean that the weapon detonates at 6k km, outside the point defense envelope of the Barbarians, inflicting 100MJ/m^2 over an are of 12m. While this would (I think) pretty much only boil the armor away, a third or fourth missile is basically guaranteed to hit components inside the ship, probably killing it. So, that should just be the end of that ;-)
Alternatively, implement the arbitrary fire delay as you said, but with a difference in hit probabilities: A given fire control needs to track its target to increase its hit percentage, this being an additional point of tech research and component building. Basically, when a FC has twenty seconds or so for tracking, it's basically guaranteed to hit the enemy - when it has to switch from missile to missile every four seconds, the shots are going to hit a lot less.
-
From what I have seen the Newtonian combat stuff seems good, especially the beam stuff; hard to tell obviously but the larger missiles should be the solution.
Does Pulsar need any icons or similar done? I have some experience with pixel art, and will in about 2 weeks have excessive amounts of time.
-
Theeht, take a look at the UI Design and Suggestion (http://aurora2.pentarch.org/index.php/topic,5223.0.html) thread.
LB did a great job earlier on designing a logo and application icon, but we still need button icons.
We are also looking into eventually replacing the generic dots on the system map with sprites or tactical display-like line art, but it might be a while before we finish the basic game play and start looking to upgrade graphics.
-
Just created an account to say how extremely happy I am that this is being made. I absolutely love Aurora, but it's unfortunately sometimes too unstable to play for long (well, by that I mean by about my fifth hour I'm starting to get tired of the slowdowns. . . ).
Unfortunately I'm way to busy at the moment to do any proper C# coding or contribute much, but let me know if you'd like a website hosting or some testing!
-
Expect to see the Spring Progress Report sometime in May.
Time for a Spring (Summer) Update soon? :)
Also consider releasing an alpha if you guys want more feedback, suggestions and activity around here. I got experience in gametesting/modding/scripting and might be able to assist a bit.
-
Heh! Sorry about that.
Pulsar4x Summer Update
Q: Is the project dead?
A: No.
Q: Who is employee of the month?
A: Nathan_, again, for everything code related. Theeht also deserves honorable mention for the graphics work.
Q: What have you, Sublight, personally done?
A: Installed Linux
What in the world does that have to do with Pulsar? Well, Nathan has been so productive that I realized the only way I could keep up would be to shelve the Mac/Linux user interface build and join in on the Windows/Linux user interface branch.
Q: When is Alpha?
A: September
We were originally trying for a 1-year anniversary release (August) at the latest, but Spring was less productive than my worst-case prediction. Once the team project leader is up to speed on the Windows/Linux branch and knows what needs coordination development should speed up.
-
Is september still the target date for alpha? :)
-
It turns out we spent the summer doing depth-first development. This gives us a small set of nearly finished concepts that can't stand alone for an Alpha release. Oops.
((This collaborative indie-game development thing is hard.))
We might have something worthy of an Alpha release in the next 9 days to meet the September goal... or we might keep pushing it back to make it just a little more playable and end up with a Christmas release.
-
In my opinion....
If you have something you want us to bug test then release it, otherwise I would wait until I have something more playable so you can get feedback on actual game mechanics.
-
Ah, so the project is still alive then.
I'd attempt to get something that's playable as fast as possible, without coding yourselfs into a corner that's going to be tricky to get out of.
I find that dev like this when you've got a couple of people doing it tends to be easier to keep up the pace if you've got something that's fun, and you're codding bits between games coz: "damn, I really wish we had feature X, ok ok I'll go add it"
-
It turns out we spent the summer doing depth-first development. This gives us a small set of nearly finished concepts that can't stand alone for an Alpha release. Oops.
((This collaborative indie-game development thing is hard.))
We might have something worthy of an Alpha release in the next 9 days to meet the September goal... or we might keep pushing it back to make it just a little more playable and end up with a Christmas release.
Guessing the September deadline just whooshed by :-)
I just noticed this project now... looks pretty cool, lots of good ideas.
Looking forward to help test it.
-
We have a rough draft of something that could be released, and bugtesting will help(I found one preparing these screenshots for example), but we'll probably wait. After I hook up component and ship class design to the UI, and put in Fast oob creation I'll probably go back and fill in some things I should have done like the event log rather than work on new features until that is completed.
-
Also:
-
I will gladly bugtest the latest version of the exe, even if it is not playable .
-
I hope you all can spend some time on this project and
revive it keep it going. The idea is too sweet to die a long slow lingering painful wilting pathetic death.
-
What language is this being programmed in Im a Computer Science student moving into my final year top 5 in my class for Programming and I would like to help out with this I love Aurora but its built on dated technology
-
What language is this being programmed in Im a Computer Science student moving into my final year top 5 in my class for Programming and I would like to help out with this I love Aurora but its built on dated technology
C#.
-
Seems ive got a bit of reading to do then ha ha
-
Seems ive got a bit of reading to do then ha ha
I've basically used this project to teach myself C#, so thats not terrible if you're still coming from C/C++. If you have a skype ID I can invite you to the discussion room we have set up, there isn't much activity on it but you can ask questions and they do tend to get answered.
-
so has the project finally bit the dust. Or is work continuing
-
I monitor their progress on github https://github. com/Pulsar4xDevs/Pulsar4x/commits/master
-
Not much to talk about right now, how bout them turrets?
-
So I've kind of gotten pissed off to the point of quitting on another 4x project I was helping with, and am looking for a new project.
Where's Pulsar4X at and if I were to help out where could I start?
-
We are using GitHub for our code repository.
Our project is at: https://github.com/Pulsar4xDevs/Pulsar4x.git (https://github.com/Pulsar4xDevs/Pulsar4x.git)
Most of the Development chatter takes place on a Skype group. PM one of us your skype user name and we can add you to the conversation.
Either look through the code for something that can be improved or is unfinished or ask Nathan_, the lead Classic Rules coder.
-
I just installed skype and hate it so much already. what happened to the good old days of IRC?
-
yeah the new versions are really obnoxious, I'm on one of the older ones that still lets you disable supernode.
-
yeah I can't bring myself to run it. not to mention it's unclear what my skype username is exactly. my email address maybe?
I've been playing Aurora the past few days to remind myself how it works, and have gotten frustrated with all the horrible little bugs in that all over again. setting a ship to overhaul causes it to complain about not being able to move for example, and no wait for shore leave order for another, and a bunch of other seemingly missing orders. etc etc etc. makes me think maybe I'm 'doing it wrong' however if so then 'doing it right' is far too obtuse. kind of feel like I should maybe note these down as specific improvements that could be made for pulsar.
I've opened up and perused the pulsar project a number of times, still looking for an easy place to start getting my fingers dirty.
-
yeah I can't bring myself to run it. not to mention it's unclear what my skype username is exactly. my email address maybe?
we can search for username or email, your skype name should be listed on your profile as skype name.
I've been playing Aurora the past few days to remind myself how it works, and have gotten frustrated with all the horrible little bugs in that all over again. setting a ship to overhaul causes it to complain about not being able to move for example, and no wait for shore leave order for another, and a bunch of other seemingly missing orders. etc etc etc. makes me think maybe I'm 'doing it wrong' however if so then 'doing it right' is far too obtuse. kind of feel like I should maybe note these down as specific improvements that could be made for pulsar.
I've opened up and perused the pulsar project a number of times, still looking for an easy place to start getting my fingers dirty.
certainly keep in mind stuff you want to add, adding a wait for shoreleave order(morale et al isn't really implemented yet) would mean updating public uint PerformOrders(uint TimeSlice) in Taskgroup.cs under entities to include the new order(you'd need to understand the orders system of course), and then updating private void BuildActionList() in TaskGroup.cs under handlers to put the order in the action listbox provided the appropriate context exists for that order. A friendly being in the locations listbox for example, there are lists of what and where is in the system locations listbox, you'd have to use those as a roadmap to find out what the user is clicking on from the selected index. So entities/taskgroup.cs Handlers/taskgroup.cs and entities/orders.cs are what you'd want to look at for that.
I can't think of anything that would be simple or self contained right now, new components are actually quite a bit of work to add in total, though just doing the definitions for them is simple enough.
-
currently moveto seems to be the only order that shows up.
Economics shows 'Earth' but earth does not seem to be in any of the systems.
maybe I'll look see if I can't implementing the follow order first, since there's another fleet to test it on.
-
currently moveto seems to be the only order that shows up.
Economics shows 'Earth' but earth does not seem to be in any of the systems.
maybe I'll look see if I can't implementing the follow order first, since there's another fleet to test it on.
Moveto is the only order being printed to the list. Basically all orders revolve around "Goto point, do something", except for special cases like follow. I've implemented some others(18 various logistics related orders) on the back end, but they require the economics system to exist in order to have meaning. The econ page is a standin and nearly all of that simply doesn't exist. After I've got Point defense and the sub pulse/interrupts system I'll move over to that since combat is fairly well fleshed out right now.
Orders... hmm.
Follow will require some modifications to Entities/Taskgroup.FollowOrders() to not delete the order once perform order reports that it is "complete". maybe a new ordersState should be created for follow since there really can't be orders after follow. On the front end it would be easiest to just print all orders for now. Filtering is going to mean some fancy logic needs to be done to determine precisely what order is being issued. Lastly at some point I'll want to move the orders and orderstate enumerations from constants to Orders.cs, it probably belongs there.
-
I started looking at how to filter the follow order to be only if the selected item in SystemLocationsListBox was a task group or contact, but I'm not fully following how it's getting the type (looking at AddMoveButton_Clicked in Handlers/TaskGroup.cs) it appears to be looping through *everything* in the listbox here when the add button is clicked, and doing a switch case inside this loop.
doesn't it just need to check the selected item index? what am I missing?
regardless, this chunk should probably be put in a function of it's own, since it'll be wanting to get called from the BuildActionList() as well.
-
I started looking at how to filter the follow order to be only if the selected item in SystemLocationsListBox was a task group or contact, but I'm not fully following how it's getting the type (looking at AddMoveButton_Clicked in Handlers/TaskGroup.cs) it appears to be looping through *everything* in the listbox here when the add button is clicked, and doing a switch case inside this loop.
doesn't it just need to check the selected item index? what am I missing?
regardless, this chunk should probably be put in a function of it's own, since it'll be wanting to get called from the BuildActionList() as well.
Index is just a number, it doesn't tell you anything about it, the Build SystemLocationListBox function can put planets, asteroids, contacts, friendly taskgroups,etc based on filtering, and the addMoveButton_clicked function needs a way of determining what exactly the system location is.The function then is looping through the SystemLocationListIndicies, which is going to be a list of 4 or 5(right now) "System Location Types". when it gets to the one it is, then it goes to the switch to determine what type of action should be undertaken.
This is BuildSystemLocationList, and as you can see not everything is put in there, so an index being selected in this list tells you nothing about what type of location is at any particular index without context.
/// <summary>
/// Build the Total System Location List here.
/// </summary>
private void BuildSystemLocationList()
{
m_oTaskGroupPanel.SystemLocationsListBox.Items.Clear();
SystemLocationListIndices.Clear();
SystemLocationListTypes.Clear();
AddPlanetsToList();
if (m_oTaskGroupPanel.DisplayContactsCheckBox.Checked == true)
AddContactsToList();
if (m_oTaskGroupPanel.DisplayTaskGroupsCheckBox.Checked == true)
AddTaskGroupsToList();
if (m_oTaskGroupPanel.DisplayWaypointsCheckBox.Checked == true)
AddWaypointsToList();
SystemLocationListIndices.Add(m_oTaskGroupPanel.SystemLocationsListBox.Items.Count);
SystemLocationListTypes.Add(SystemLocationListType.Count);
}
you don't have to worry about that right now though, just print the order in BuildActionList() and don't worry about filtering(it can be done later), and just don't click follow Planet/waypoint/etc, and AddMoveButton_Clicked will "automatically" take care of issuing the right order(again as long as you don't try to follow a planet).
If you do want to do orders filtering, then you have to update BuildActionList() to duplicate the for loop, and the switch present in AddMoveButton_Clicked() if an index is selected.
You basically have to duplicate the logic involved in putting entries into these lists if you want to get useful information out of them in other words, so look at how taskgroups are added to the list for example to see how taskgroups should be extracted from it based on index.
-
There's got to be an easier less obtuse way than that,
I'll have a play around and see what I can come up with.
-
There's got to be an easier less obtuse way than that,
I'll have a play around and see what I can come up with.
Well there is, just don't worry about the filtering for now(and any potential errors this might cause under certain circumstances),for expediency to see if your follow function works. Filtering can be done later. That function is certainly no where near complete though, so if you do find something better that does help.
-
how about something a little more along these lines:
https://github.com/se5a/Pulsar4x/blob/master/Pulsar4X/Pulsar4X.UI/Handlers/TaskGroup.cs
smaller.
more efficient. (looking up values in dictionaries instead of looping)
easier to read. (imo anyway)
it's a little messy, I need to clean it up a bit, but should give you some idea of what I'm meaning.
-
actually you could probably do away with the new class and just have the dictionary be <string,GameEntity> then check the values Type, instead of looking at the enum:
Dictionary SystemLocationDict<string, GameEntity>;
GameEntity entity = SystemLocationDict[m_oTaskGroupPanel.SystemLocationsListBox.SelectedItem.ToString()];
if (entity is Planet)
{
NewOrder = new Orders((Constants.ShipTN.OrderType)ActionIndex, -1, -1, 0, (Planet)entity);
CurrentTaskGroup.IssueOrder(NewOrder);
}
-
probably should keep the class, I don't think theres a type in gameEntity, though there is one in StarSystemEntity, I would also be a little more paranoid about checking certain things like the planet assignment to be sure that the planet and the TG are in the same star system, the contact to see if it is actually in the contact list,etc , but that does look good.
more efficient. (looking up values in dictionaries instead of looping)
You're doing string compares though, still efficiency isn't that important for the front end.
easier to read. (imo anyway)
As a personal preference I'd rather have a switch than the else ifs, but thats very minor.
lastly, I pushed a bugfix to this file before you grabbed it, so that might be a problem with merging your version and mine, here is the section in question:
SystemLocationListType Type = SystemLocationListType.Count;
if (loop == 0)
{
newIndex = PlaceIndex;
Type = SystemLocationListType.Planets;
#warning special case zero here, if another SystemLocationListType is made to be loop = 0, then Planets here will have to change.
}
else
{
newIndex = PlaceIndex - SystemLocationListIndices[loop-1];
Type = SystemLocationListTypes[loop - 1];
}
/// <summary>
/// Which type is this?
/// </summary>
switch (Type)
-
I don't think theres a type in gameEntity,
I don't quite follow... the above example checking if (entity is Planet) does work (Planet, and everything else I think does inherit from GameEntity)
Yeah I can add some more checks, though you can go overboard and start hampering planning for something that may not be the case now, but will be when the TG is going to carry out the order later. might be better to just check for these problems when the TG is attempting to carry out the order (and handle it better than Aurora) since it's going to hit cases where this TG is going to want to interact with another TG or contact that is not in the same system, has been destroyed, or lost sight anyway.
the problem with looping is that you can get into an O(n^2) case without realizing it. a dictionary however uses a hashtable so it's close to O(1). but yeah, in this case the actual time would have been negligible.
-
I don't quite follow... the above example checking if (entity is Planet) does work (Planet, and everything else I think does inherit from GameEntity)
I was thinking of the SSEntityType when you mentioned type. there are a couple of things strewn throughout the code that don't inherit from GameEntity, but I think they are a non-factor.
Yeah I can add some more checks, though you can go overboard and start hampering planning for something that may not be the case now, but will be when the TG is going to carry out the order later. might be better to just check for these problems when the TG is attempting to carry out the order (and handle it better than Aurora) since it's going to hit cases where this TG is going to want to interact with another TG or contact that is not in the same system, has been destroyed, or lost sight anyway.
Orders involving TGs that have been destroyed are already handled in simEntity, anyway this is more for error checking the UI since it is already set up so that only data from the same star system can get in. so something wierd would have to happen to get a TG in a different star system. I hadn't considered the contact/TG jumps/docks condition just yet, that I'll have to come back to when those are implemented, and since that could happen in the middle of an order it would have to be checked every tick. Also I may have to rework how contact orders are handled since they are passed along as TG orders right now.
Orders to taskgroups that have been destroyed are just dropped now with a note to the faction message log that such and such a ship order is gone, what do you think should be done there?
-
if it's an enemy/neutral contact thats seen to be destroyed I'd probably drop it and move to the next order. (with an option somewhere to pause on such things)
if it's an enemy/neutral contact that's disappeared yeah replacing it with a waypoint would be a good idea.
if it's TG of own empire, then I'd have it follow in the case of it going into another system(if possible) and pause if not possible.
destroyed I'd probably drop and move to next order but default the pause option on for this one.
I wonder if a pause if dropped option on the order itself might be useful...
-
You should be able to see the dev forum now, not much is there though.
-
Oh cool! thanks. I'll have a read through there. I started tidying up the above code today, but then got distracted. and kept changing my mind on how best to do it.
-
you should also be added to pulsar4xdevs on github now. Also for the orders options, I'm thinking that should be some sort of configuration thing.
-
Is there a place I can see the outline for Pulsar 4X's goals / plans? What features are planned, similarities / differences from Aurora, etc. I would check the wiki, but it seems to be down.
-
Is there a place I can see the outline for Pulsar 4X's goals / plans? What features are planned, similarities / differences from Aurora, etc. I would check the wiki, but it seems to be down.
There is not, but the goal for the TN rules set is to duplicate AuroraTN as faithfully as possible. the NA rules set is still on the drawing board, but it takes many concepts from Newtonian Aurora.
-
Alright, have you laid out the general structure of the code somewhere? And if there were one feature I would think you'd want to differ from Aurora it would be the UI, so do you have any plans for how that would be structured? There are a lot of small things about Aurora's UI that could be fixed, but I also think a general restructuring could help make important information more visible to players and make fiddling with your empire less of a hassle.
If you have room, I might consider contributing to Pulsar, as I could use something to work on over the summer and on the side during the school year. I don't know C#, but I do know C++ and C so it shouldn't be too hard to pick up.
-
Alright, have you laid out the general structure of the code somewhere? And if there were one feature I would think you'd want to differ from Aurora it would be the UI, so do you have any plans for how that would be structured? There are a lot of small things about Aurora's UI that could be fixed, but I also think a general restructuring could help make important information more visible to players and make fiddling with your empire less of a hassle.
If you have room, I might consider contributing to Pulsar, as I could use something to work on over the summer and on the side during the school year. I don't know C#, but I do know C++ and C so it shouldn't be too hard to pick up.
There are notable parts of how the code is laid out in the dev forum, and on the skype chat history we're using, mainly you'd have to ask questions if there is an area you are interested in and the comments aren't revealing. UI improvements are eventually going to be done, but for right now I'm just getting the combat engine to a baseline level of functionality. We will not completely redo the UI though, it does work for the most part.
-
Hello,
I watch for this project at least 4 months and I'm very happy because it's hard find good looking code for learning. But I have a little question: it's normal that I have only rectangles where must be text? In GLFont. cs I clearly see what text must be drawn right but I have only that:
hxxp: i. imgur. com/IDDuM0w. png
Sorry but I can't attach this as image because of url modification.
-
Not sure if it's an anti-pattern or not, but most WinForms UI elements have a Tag property of Type "object," so you can throw the actual GameEntity associated with the object behind a ListBoxItem into its Tag and then just do some type checking when you're trying to do something with that ListBoxItem.
-
Hello,
I watch for this project at least 4 months and I'm very happy because it's hard find good looking code for learning. But I have a little question: it's normal that I have only rectangles where must be text? In GLFont. cs I clearly see what text must be drawn right but I have only that:
hxxp: i. imgur. com/IDDuM0w. png
Sorry but I can't attach this as image because of url modification.
No, text should be displayed. one interesting thing to note is that the taskgroup names aren't displayed at all in your image, those use a different font. I'm not sure what could cause this however. I assume you're running on linux, our cross platform support is somewhat lacking at the moment. I've attached an image of what mine looks like further down, and I'll post the link to your image here:http://i.imgur.com/IDDuM0w.png
Not sure if it's an anti-pattern or not, but most WinForms UI elements have a Tag property of Type "object," so you can throw the actual GameEntity associated with the object behind a ListBoxItem into its Tag and then just do some type checking when you're trying to do something with that ListBoxItem.
I'll look into that, tag does seem to be there, but it appears to be for the entire listbox as a whole, rather than an entry by entry case. In any event se5a's solution seems like the best and most accessible one at the moment, so if and when I revisit orders, if it hasn't already been done I'll put that in there.
-
I'll look into that, tag does seem to be there, but it appears to be for the entire listbox as a whole, rather than an entry by entry case. In any event se5a's solution seems like the best and most accessible one at the moment, so if and when I revisit orders, if it hasn't already been done I'll put that in there.
ListBoxes and ComboBoxes store ObjectCollections instead of an array of strongly typed items. This basically means you could stuff anything you want in them. What's displayed in the ListBox or ComboBox is generally the result of the object's ToString(). So you could create a strongly-typed Order class and stuff a bunch of those in. The Order object itself would know what kind of order it is through internal logic, so you don't have to figure that out externally. Just grab your SelectedItem, cast it back to Order, and then use that object as necessary in your order parsing logic.
This might be what se5a did, I haven't actually looked at any of the code.
-
That is actually what Se5a did I think:
m_oTaskGroupPanel.SystemLocationsListBox.DataSource = SystemLocationDict.Keys.ToList();
which probably winds up using even less space then how I am doing it.
-
Oh, no, he's using data binding. Binding the contents of the ListBox to a dictionary's keys. That's probably a better pattern, doesn't entangle the model with the view nearly as much as otherwise.
-
yeah, you can get the actual object itself easily this way.
Dictionaries are pretty much my favorite animal datatype.
-
No, text should be displayed. one interesting thing to note is that the taskgroup names aren't displayed at all in your image, those use a different font. I'm not sure what could cause this however. I assume you're running on linux, our cross platform support is somewhat lacking at the moment. I've attached an image of what mine looks like further down, and I'll post the link to your image here:hxxp: i. imgur. com/IDDuM0w. png
No, I'm running on windows 7 x64 but with russian localization. It might be cause of problem?
And I built project via VS2010 Express.
-
No, I'm running on windows 7 x64 but with russian localization. It might be cause of problem?
And I built project via VS2010 Express.
Maybe, post the pulsar4x.log file if you can, it will have stuff like your opengl version in it, and may potentially reveal the issue.
-
Here is it
-
Here is it
ok. I've dont a slightly better job logging in resource manager, where I suspect the issue may be, and did a pretty dumb swap of two of the reads to make those reads happen in the order they'd occur in the file.
-
Newer version of logs. I have no idea, it's looks alright.
-
Newer version of logs. I have no idea, it's looks alright.
Yeah the log itself doesn't reveal the problem unfortunately. both dumb things that I hoped might have been it weren't. Guess I have some googling to do if our opengl programmer doesn't check back before then.
[edit]
does moving taskgroups do anything? render and refresh may be different.
[/edit]
-
does moving taskgroups do anything? render and refresh may be different.
Nothing changed.
But I'm absolutely sure cause of trouble in my russian localization, comma(non point) separator or something like that.
-
Nothing changed.
But I'm absolutely sure cause of trouble in my russian localization, comma(non point) separator or something like that.
well I've got some more logging on the GLFont.render() side of things, maybe that will tease it out. this will lag the program a bit, and the log file will balloon to gigantic sizes. I only need the first few references, the rest are all going to be the same. So please quickly start up, press f3 to bring up the system map, and then close execution, and send that log.
I only need 1 of these, the rest of the file after the 1st instance of this can be deleted. the stuff beforehand is still valuable.
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 1 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 2 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 3 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 4 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 5 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 6 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 7 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 8 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 9 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 10 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 11 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 12 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 13 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 14 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 15 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 16 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 17 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 18 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test 19 ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test ID: 4
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
2014-07-08 23:37:43,218 [1] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
-
2014-07-09 11:18:17,483 [7] INFO (Pulsar4X.UI.Program) Program Started
2014-07-09 11:19:14,475 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLCanvas) Highest OpenGL Version Initialised is 4.4.0
2014-07-09 11:19:14,485 [7] INFO (Pulsar4X.UI.GLUtilities.GLCanvas) UI: GLCanvas3.X Loaded Successfully, Open GL Version: 4.4.0
2014-07-09 11:19:14,485 [7] INFO (Pulsar4X.UI.GLUtilities.GLCanvas) UI: GLSL Version: 4.40 NVIDIA via Cg compiler
2014-07-09 11:19:14,485 [7] INFO (Pulsar4X.UI.GLUtilities.GLCanvas) UI: Renderer: GeForce GT 440/PCIe/SSE2
2014-07-09 11:19:14,486 [7] INFO (Pulsar4X.UI.GLUtilities.GLCanvas) UI: Vender: NVIDIA Corporation
2014-07-09 11:19:14,486 [7] INFO (Pulsar4X.UI.GLUtilities.GLCanvas) UI: Extensions: GL_AMD_multi_draw_indirect GL_ARB_arrays_of_arrays GL_ARB_base_instance GL_ARB_blend_func_extended GL_ARB_buffer_storage GL_ARB_clear_buffer_object GL_ARB_clear_texture GL_ARB_color_buffer_float GL_ARB_compatibility GL_ARB_compressed_texture_pixel_storage GL_ARB_conservative_depth GL_ARB_compute_shader GL_ARB_compute_variable_group_size GL_ARB_copy_buffer GL_ARB_copy_image GL_ARB_debug_output GL_ARB_depth_buffer_float GL_ARB_depth_clamp GL_ARB_depth_texture GL_ARB_draw_buffers GL_ARB_draw_buffers_blend GL_ARB_draw_indirect GL_ARB_draw_elements_base_vertex GL_ARB_draw_instanced GL_ARB_enhanced_layouts GL_ARB_ES2_compatibility GL_ARB_ES3_compatibility GL_ARB_explicit_attrib_location GL_ARB_explicit_uniform_location GL_ARB_fragment_coord_conventions GL_ARB_fragment_layer_viewport GL_ARB_fragment_program GL_ARB_fragment_program_shadow GL_ARB_fragment_shader GL_ARB_framebuffer_no_attachments GL_ARB_framebuffer_object GL_ARB_framebuffer_sRGB GL_ARB_geometry_shader4 GL_ARB_get_program_binary GL_ARB_gpu_shader5 GL_ARB_gpu_shader_fp64 GL_ARB_half_float_pixel GL_ARB_half_float_vertex GL_ARB_imaging GL_ARB_indirect_parameters GL_ARB_instanced_arrays GL_ARB_internalformat_query GL_ARB_internalformat_query2 GL_ARB_invalidate_subdata GL_ARB_map_buffer_alignment GL_ARB_map_buffer_range GL_ARB_multi_bind GL_ARB_multi_draw_indirect GL_ARB_multisample GL_ARB_multitexture GL_ARB_occlusion_query GL_ARB_occlusion_query2 GL_ARB_pixel_buffer_object GL_ARB_point_parameters GL_ARB_point_sprite GL_ARB_program_interface_query GL_ARB_provoking_vertex GL_ARB_robust_buffer_access_behavior GL_ARB_robustness GL_ARB_sample_shading GL_ARB_sampler_objects GL_ARB_seamless_cube_map GL_ARB_separate_shader_objects GL_ARB_shader_atomic_counters GL_ARB_shader_bit_encoding GL_ARB_shader_draw_parameters GL_ARB_shader_group_vote GL_ARB_shader_image_load_store GL_ARB_shader_image_size GL_ARB_shader_objects GL_ARB_shader_precision GL_ARB_query_buffer_object GL_ARB_shader_storage_buffer_object GL_ARB_shader_subroutine GL_ARB_shader_texture_lod GL_ARB_shading_language_100 GL_ARB_shading_language_420pack GL_ARB_shading_language_include GL_ARB_shading_language_packing GL_ARB_shadow GL_ARB_sparse_texture GL_ARB_stencil_texturing GL_ARB_sync GL_ARB_tessellation_shader GL_ARB_texture_border_clamp GL_ARB_texture_buffer_object GL_ARB_texture_buffer_object_rgb32 GL_ARB_texture_buffer_range GL_ARB_texture_compression GL_ARB_texture_compression_bptc GL_ARB_texture_compression_rgtc GL_ARB_texture_cube_map GL_ARB_texture_cube_map_array GL_ARB_texture_env_add GL_ARB_texture_env_combine GL_ARB_texture_env_crossbar GL_ARB_texture_env_dot3 GL_ARB_texture_float GL_ARB_texture_gather GL_ARB_texture_mirror_clamp_to_edge GL_ARB_texture_mirrored_repeat GL_ARB_texture_multisample GL_ARB_texture_non_power_of_two GL_ARB_texture_query_levels GL_ARB_texture_query_lod GL_ARB_texture_rectangle GL_ARB_texture_rg GL_ARB_texture_rgb10_a2ui GL_ARB_texture_stencil8 GL_ARB_texture_storage GL_ARB_texture_storage_multisample GL_ARB_texture_swizzle GL_ARB_texture_view GL_ARB_timer_query GL_ARB_transform_feedback2 GL_ARB_transform_feedback3 GL_ARB_transform_feedback_instanced GL_ARB_transpose_matrix GL_ARB_uniform_buffer_object GL_ARB_vertex_array_bgra GL_ARB_vertex_array_object GL_ARB_vertex_attrib_64bit GL_ARB_vertex_attrib_binding GL_ARB_vertex_buffer_object GL_ARB_vertex_program GL_ARB_vertex_shader GL_ARB_vertex_type_10f_11f_11f_rev GL_ARB_vertex_type_2_10_10_10_rev GL_ARB_viewport_array GL_ARB_window_pos GL_ATI_draw_buffers GL_ATI_texture_float GL_ATI_texture_mirror_once GL_S3_s3tc GL_EXT_texture_env_add GL_EXT_abgr GL_EXT_bgra GL_EXT_bindable_uniform GL_EXT_blend_color GL_EXT_blend_equation_separate GL_EXT_blend_func_separate GL_EXT_blend_minmax GL_EXT_blend_subtract GL_EXT_compiled_vertex_array GL_EXT_Cg_shader GL_EXT_depth_bounds_test GL_EXT_direct_state_access GL_EXT_draw_buffers2 GL_EXT_draw_instanced GL_EXT_draw_range_elements GL_EXT_fog_coord GL_EXT_framebuffer_blit GL_EXT_framebuffer_multisample GL_EXTX_framebuffer_mixed_formats GL_EXT_framebuffer_multisample_blit_scaled GL_EXT_framebuffer_object GL_EXT_framebuffer_sRGB GL_EXT_geometry_shader4 GL_EXT_gpu_program_parameters GL_EXT_gpu_shader4 GL_EXT_multi_draw_arrays GL_EXT_packed_depth_stencil GL_EXT_packed_float GL_EXT_packed_pixels GL_EXT_pixel_buffer_object GL_EXT_point_parameters GL_EXT_provoking_vertex GL_EXT_rescale_normal GL_EXT_secondary_color GL_EXT_separate_shader_objects GL_EXT_separate_specular_color GL_EXT_shader_image_load_store GL_EXT_shader_integer_mix GL_EXT_shadow_funcs GL_EXT_stencil_two_side GL_EXT_stencil_wrap GL_EXT_texture3D GL_EXT_texture_array GL_EXT_texture_buffer_object GL_EXT_texture_compression_dxt1 GL_EXT_texture_compression_latc GL_EXT_texture_compression_rgtc GL_EXT_texture_compression_s3tc GL_EXT_texture_cube_map GL_EXT_texture_edge_clamp GL_EXT_texture_env_combine GL_EXT_texture_env_dot3 GL_EXT_texture_filter_anisotropic GL_EXT_texture_integer GL_EXT_texture_lod GL_EXT_texture_lod_bias GL_EXT_texture_mirror_clamp GL_EXT_texture_object GL_EXT_texture_shared_exponent GL_EXT_texture_sRGB GL_EXT_texture_sRGB_decode GL_EXT_texture_storage GL_EXT_texture_swizzle GL_EXT_timer_query GL_EXT_transform_feedback2 GL_EXT_vertex_array GL_EXT_vertex_array_bgra GL_EXT_vertex_attrib_64bit GL_EXT_import_sync_object GL_IBM_rasterpos_clip GL_IBM_texture_mirrored_repeat GL_KHR_debug GL_KTX_buffer_region GL_NV_bindless_multi_draw_indirect GL_NV_blend_equation_advanced GL_NV_blend_square GL_NV_compute_program5 GL_NV_conditional_render GL_NV_copy_depth_to_color GL_NV_copy_image GL_NV_depth_buffer_float GL_NV_depth_clamp GL_NV_draw_texture GL_NV_ES1_1_compatibility GL_NV_ES3_1_compatibility GL_NV_explicit_multisample GL_NV_fence GL_NV_float_buffer GL_NV_fog_distance GL_NV_fragment_program GL_NV_fragment_program_option GL_NV_fragment_program2 GL_NV_framebuffer_multisample_coverage GL_NV_geometry_shader4 GL_NV_gpu_program4 GL_NV_gpu_program4_1 GL_NV_gpu_program5 GL_NV_gpu_program5_mem_extended GL_NV_gpu_program_fp64 GL_NV_gpu_shader5 GL_NV_half_float GL_NV_light_max_exponent GL_NV_multisample_coverage GL_NV_multisample_filter_hint GL_NV_occlusion_query GL_NV_packed_depth_stencil GL_NV_parameter_buffer_object GL_NV_parameter_buffer_object2 GL_NV_path_rendering GL_NV_pixel_data_range GL_NV_point_sprite GL_NV_primitive_restart GL_NV_register_combiners GL_NV_register_combiners2 GL_NV_shader_atomic_counters GL_NV_shader_atomic_float GL_NV_shader_buffer_load GL_NV_shader_storage_buffer_object GL_NV_texgen_reflection GL_NV_texture_barrier GL_NV_texture_compression_vtc GL_NV_texture_env_combine4 GL_NV_texture_expand_normal GL_NV_texture_multisample GL_NV_texture_rectangle GL_NV_texture_shader GL_NV_texture_shader2 GL_NV_texture_shader3 GL_NV_transform_feedback GL_NV_transform_feedback2 GL_NV_vertex_array_range GL_NV_vertex_array_range2 GL_NV_vertex_attrib_integer_64bit GL_NV_vertex_buffer_unified_memory GL_NV_vertex_program GL_NV_vertex_program1_1 GL_NV_vertex_program2 GL_NV_vertex_program2_option GL_NV_vertex_program3 GL_NVX_conditional_render GL_NVX_gpu_memory_info GL_NV_shader_thread_group GL_KHR_blend_equation_advanced GL_SGIS_generate_mipmap GL_SGIS_texture_lod GL_SGIX_depth_texture GL_SGIX_shadow GL_SUN_slice_accum GL_WIN_swap_hint WGL_EXT_swap_control
2014-07-09 11:19:16,073 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) OpenGL Loading Texture ./Resources/Textures/DefaultTexture.png: NoError
2014-07-09 11:19:16,104 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Coordinates: 0/0,0/0
2014-07-09 11:19:16,104 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ! Coordinates: 0/0,0/0
2014-07-09 11:19:16,104 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: " Coordinates: 0/0,0/0
2014-07-09 11:19:16,106 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: # Coordinates: 0/0,0/0
2014-07-09 11:19:16,106 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: $ Coordinates: 0/0,0/0
2014-07-09 11:19:16,106 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: % Coordinates: 0/0,0/0
2014-07-09 11:19:16,106 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: & Coordinates: 0/0,0/0
2014-07-09 11:19:16,106 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ' Coordinates: 0/0,0/0
2014-07-09 11:19:16,106 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ( Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ) Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: * Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: + Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: , Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: - Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: . Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: / Coordinates: 0/0,0/0
2014-07-09 11:19:16,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 0 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 1 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 2 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 3 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 4 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 5 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 6 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 7 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 8 Coordinates: 0/0,0/0
2014-07-09 11:19:16,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: 9 Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: : Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ; Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: < Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: = Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: > Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ? Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: @ Coordinates: 0/0,0/0
2014-07-09 11:19:16,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: A Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: B Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: C Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: D Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: E Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: F Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: G Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: H Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: I Coordinates: 0/0,0/0
2014-07-09 11:19:16,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: J Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: K Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: L Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: M Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: N Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: O Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: P Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Q Coordinates: 0/0,0/0
2014-07-09 11:19:17,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: R Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: S Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: T Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: U Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: V Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: W Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: X Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Y Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Z Coordinates: 0/0,0/0
2014-07-09 11:19:17,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: [ Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: \ Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ] Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ^ Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: _ Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ` Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: a Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: b Coordinates: 0/0,0/0
2014-07-09 11:19:17,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: c Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: d Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: e Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: f Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: g Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: h Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: i Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: j Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: k Coordinates: 0/0,0/0
2014-07-09 11:19:17,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: l Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: m Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: n Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: o Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: p Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: q Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: r Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: s Coordinates: 0/0,0/0
2014-07-09 11:19:17,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: t Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: u Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: v Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: w Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: x Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: y Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: z Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: { Coordinates: 0/0,0/0
2014-07-09 11:19:18,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: | Coordinates: 0/0,0/0
2014-07-09 11:19:18,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: } Coordinates: 0/0,0/0
2014-07-09 11:19:18,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ~ Coordinates: 0/0,0/0
2014-07-09 11:19:18,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) Loaded GLFont Data File ./Resources/Fonts/DejaVuSansMonoBold.xml
2014-07-09 11:19:18,310 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) OpenGL Loading Texture ./Resources/Fonts/DejaVuSansMonoBold.png: NoError
2014-07-09 11:19:18,311 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) Loaded Texture ID: 2
2014-07-09 11:19:18,341 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) OpenGL Loading Texture ./Resources/Textures/DefaultIcon.png: NoError
2014-07-09 11:19:18,343 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Coordinates: 0/0,0/0
2014-07-09 11:19:18,343 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: A Coordinates: 0/0,0/0
2014-07-09 11:19:18,343 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: B Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: C Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: D Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: E Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: F Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: G Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: H Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: I Coordinates: 0/0,0/0
2014-07-09 11:19:18,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: J Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: K Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: L Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: M Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: N Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: O Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: P Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Q Coordinates: 0/0,0/0
2014-07-09 11:19:18,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: R Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: S Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: T Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: U Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: V Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: W Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: X Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Y Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: Z Coordinates: 0/0,0/0
2014-07-09 11:19:18,885 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: a Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: b Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: c Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: d Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: e Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: f Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: g Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: h Coordinates: 0/0,0/0
2014-07-09 11:19:19,085 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: i Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: j Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: k Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: l Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: m Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: n Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: o Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: p Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: q Coordinates: 0/0,0/0
2014-07-09 11:19:19,285 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: r Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: s Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: t Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: u Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: v Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: w Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: x Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: y Coordinates: 0/0,0/0
2014-07-09 11:19:19,485 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: z Coordinates: 0/0,0/0
2014-07-09 11:19:19,685 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) Loaded GLFont Data File ./Resources/Fonts/PulsarFont.xml
2014-07-09 11:19:19,723 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) OpenGL Loading Texture ./Resources/Fonts/PulsarFont.png: NoError
2014-07-09 11:19:19,723 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) Loaded Texture ID: 4
2014-07-09 11:19:19,900 [7] INFO (Pulsar4X.UI.Helpers.ResourceManager) OpenGL Loading Texture ./Resources/Textures/DefaultTGIcon.png: NoError
2014-07-09 11:19:20,002 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 1 ID: 4
2014-07-09 11:19:20,003 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 2 ID: 4
2014-07-09 11:19:20,003 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 3 ID: 4
2014-07-09 11:19:20,003 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 4 ID: 4
2014-07-09 11:19:20,003 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 5 ID: 4
2014-07-09 11:19:20,003 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 6 ID: 4
2014-07-09 11:19:20,003 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 7 ID: 4
2014-07-09 11:19:20,004 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 8 ID: 4
2014-07-09 11:19:20,004 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 9 ID: 4
2014-07-09 11:19:20,085 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 10 ID: 4
2014-07-09 11:19:20,085 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A 11 ID: 4
2014-07-09 11:19:20,085 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test A ID: 4
2014-07-09 11:19:20,086 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 1 ID: 4
2014-07-09 11:19:20,086 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 2 ID: 4
2014-07-09 11:19:20,086 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 3 ID: 4
2014-07-09 11:19:20,086 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 4 ID: 4
2014-07-09 11:19:20,086 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 5 ID: 4
2014-07-09 11:19:20,086 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 6 ID: 4
2014-07-09 11:19:20,285 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 7 ID: 4
2014-07-09 11:19:20,285 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B 8 ID: 4
2014-07-09 11:19:20,285 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Test B ID: 4
2014-07-09 11:19:20,290 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
2014-07-09 11:19:20,290 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
2014-07-09 11:19:20,290 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
2014-07-09 11:19:20,290 [7] DEBUG (Pulsar4X.UI.GLUtilities.GLFont) GLFont.Render() | Text:Combat Taskgroup ID: 2
-
Ok that revealed the problem, it isn't properly reading in the character positions. Yet another logging thing pushed, this one should narrow it down to either float.tryparse of getAttribute. I think float.tryparse is what is failing for some reason. once again, please post the log from the latest build, this one shouldn't ballon into infinity.
heres what it looks like on mine:
2014-07-09 12:22:01,859 [10] INFO (Pulsar4X.UI.Helpers.ResourceManager) szBuffer: 0.0298507456 True
2014-07-09 12:22:01,859 [10] INFO (Pulsar4X.UI.Helpers.ResourceManager) szBuffer: 0.087064676 True
2014-07-09 12:22:01,859 [10] INFO (Pulsar4X.UI.Helpers.ResourceManager) szBuffer: 0.01 True
2014-07-09 12:22:01,859 [10] INFO (Pulsar4X.UI.Helpers.ResourceManager) szBuffer: 0.165 True
2014-07-09 12:22:01,859 [10] INFO (Pulsar4X.UI.Helpers.ResourceManager) ResourceManager.cs Char: ! Coordinates: 0.02985075/0.01,0.08706468/0.165
-
Here is logs.
I start scared about this.
-
Here is logs.
I start scared about this.
Thank you for posting that, float.tryparse is indeed the error. I've pushed a patch that may resolve the issue, if it doesn't there is a far greater problem for your system then I can fix. another thing to do(since it uses much the same code) is to press F6, go to the combat summary, select the 1st warship, select point defense drop down and pick area defense, type 1000.1 into the PD range text box, and press set mode. then look at the combat summary, it should read:
Primary III FC R96K T6K #1 (AreaDefense 1,000.1): No Target Assignment
If this patch doesn't work on the text display, does the above work with point defense settings?
on the other hand, if it is just the text character readin that is failing that can perhaps be hardcoded as a "temporary" workaround.
-
Text on map are still rectangles.
When I typed "1000. 1" - i've got "Primary III FC R96K T6K #2 (AreaDefense 0,0): No Target Assignment"
but when I typed "1000,1" - i've got "Primary III FC R96K T6K #1 (AreaDefense 1 000,1): No Target Assignment"
So trouble definitly in C# localization.
And sorry if I did some mistakes, I still learning en.
-
I review System. Globalization, it's have all required stuff I think. But I rarely used this stuff and still don't know where is trouble in code.
-
I review System. Globalization, it's have all required stuff I think. But I rarely used this stuff and still don't know where is trouble in code.
thank you for all your efforts, I think your original suspicion that it was the comma separator is correct. The next thing to try later is posting a copy of the font files with commas instead of periods, if your tryparse is looking for commas and not periods then that would explain things. I'll post a file to that effect later.
A new version should be up that forces the appropriate settings for tryparse, though there will almost certainly be other places, we'll get those as they pop up.
-
A new version should be up that forces the appropriate settings for tryparse, though there will almost certainly be other places, we'll get those as they pop up.
Trouble was definitly here. Now I can see text normally but fonts is not so good, huh.
http://s1.hostingkartinok.com/uploads/images/2014/07/3b140df42d6dfd5ce43459d5765a4d36.png
Thanks.
-
Trouble was definitly here. Now I can see text normally but fonts is not so good, huh.
http://s1.hostingkartinok.com/uploads/images/2014/07/3b140df42d6dfd5ce43459d5765a4d36.png
Thanks.
Good to hear.
-
Hey, just so you guys know, there's a 4x/grand strategy-centric group that I am part of which has been following aurora and pulsar 4x for years. Keep up the good work, we can hardly wait for you to release a true playable version of your game.