Does anyone know any A&A-like games that are free and require no download?
Axis & Allies XML
-
Just thought I could throw in a good resource. Mapview uses XML files to generate a user customizable file to make modules. Mot has used a Visual basic program to create a compiler. You make your xml text and drag the file onto the compiler. Works quite well actually and I’ve made a bunch of modules. Mot has been kinda out of the scene since having a kid. I guess I have been too. He might be a good source of ideas or info so you might check on www.motcreations.com
Here is an example of the A&A revised xml text I used.<module_def format_version=“1”><game_info><title>Axis & Allies Revised Edition</title>
<author>Der Panzinator</author>
<url>www.axisdomain.0catch.com</url>
<copyright>n/a</copyright>
<min_mv_version>1.2.0</min_mv_version></game_info>
<game_id><unique_id>AA_Revised</unique_id>
<version>1</version></game_id>
<board_settings><board_image>AArevisedMap.gif</board_image>
<label_font_name>Arial</label_font_name>
<label_font_size>10</label_font_size>
<label_is_transparent>False</label_is_transparent></board_settings>
<image_settings>
<mask_html_color>#FFFFCC</mask_html_color>
<pallet_img_width>44</pallet_img_width>
<pallet_img_height>24</pallet_img_height>
<map_image_width>44</map_image_width>
<map_image_height>24</map_image_height>
</image_settings>
<tabs><category name=“Russia”><token token_id=“russian_flag” token_type=“Image”><pallet_image>rus_flag.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>rus_flag.gif</map_image>
Flag
<click_region_x>0</click_region_x>
<click_region_y>0</click_region_y>
<click_region_w>44</click_region_w>
<click_region_h>24</click_region_h></token>
<token token_id=“russian_inf” token_type=“Quantity”><pallet_image>rus_inf.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>rus_inf.gif</map_image>
Infantry
<click_region_x>0</click_region_x>
<click_region_y>0</click_region_y>
<click_region_w>44</click_region_w>
<click_region_h>24</click_region_h></token>
<token token_id=“russian_arm” token_type=“Quantity”><pallet_image>rus_arm.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>rus_arm.gif</map_image>
Armor
<click_region_x>10</click_region_x>
<click_region_y>4</click_region_y>
<click_region_w>20</click_region_w>
<click_region_h>20</click_region_h></token>
<token token_id=“russian_ftr” token_type=“Quantity”><pallet_image>rus_ftr.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>rus_ftr.gif</map_image>
Fighter
<click_region_x>0</click_region_x>
<click_region_y>0</click_region_y>
<click_region_w>44</click_region_w>
<click_region_h>24</click_region_h></token>
<token token_id=“russian_bb” token_type=“Quantity”><pallet_image>rus_bb.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>rus_bb.gif</map_image>
Battleship
<click_region_x>0</click_region_x>
<click_region_y>0</click_region_y>
<click_region_w>44</click_region_w>
<click_region_h>24</click_region_h></token></category>
<category name=“Misc”><token token_id=“misc_remarks” token_type=“Text”><pallet_image>misc_remarks.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>misc_remarks.gif</map_image>
Comments
<click_region_x>10</click_region_x>
<click_region_y>0</click_region_y>
<click_region_w>20</click_region_w>
<click_region_h>28</click_region_h>
<default_text>Special Orders</default_text></token>
<token token_id=“misc_complex” token_type=“Image”><pallet_image>misc_complex.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>misc_complex.gif</map_image>
Complex
<click_region_x>10</click_region_x>
<click_region_y>4</click_region_y>
<click_region_w>20</click_region_w>
<click_region_h>20</click_region_h></token>
<token token_id=“misc_production” token_type=“Numeric”><pallet_image>misc_production.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>misc_production.gif</map_image>
Production
<click_region_x>10</click_region_x>
<click_region_y>4</click_region_y>
<click_region_w>20</click_region_w>
<click_region_h>20</click_region_h></token>
<token token_id=“misc_money” token_type=“Numeric”><pallet_image>misc_money.gif</pallet_image>
<drag_image>drag_drop.bmp</drag_image>
<map_image>misc_money.gif</map_image>
Income
<click_region_x>10</click_region_x>
<click_region_y>4</click_region_y>
<click_region_w>20</click_region_w>
<click_region_h>20</click_region_h></token>
<token token_id=“misc_red_arrow” token_type=“Arrow”><pallet_image>misc_red_arr_pal.gif</pallet_image>
<drag_image>misc_red_arr_drag.gif</drag_image>
<map_image>clear.gif</map_image>
Attack
<click_region_x>10</click_region_x>
<click_region_y>4</click_region_y>
<click_region_w>20</click_region_w>
<click_region_h>20</click_region_h>
<line_html_color>#CC3300</line_html_color></token></category></tabs>
<initial_setup_cmf>AARevised_Initial_Setup.cmf</initial_setup_cmf></module_def> -
Der Panzinator, can you do me a big favor and invite Mot to this conversation? I’d do it myself but I’m getting tired of creating new accouts everywhere. ;-) It shouldn’t comsume much of his time at all.
-
Hi guys, just poking my head in here. It was suggested that I stop by to possibly add my two cents.
Here it goes:
First, I suggest that the A&A XML file (henceforth called AAX file in this post to save me some typing :) ) be used in an “export/import” format as opposed to the native game storage for currenet and future programs. This will increase adoption and remove any burden an “outside” format may have on future developement. (Imagine not being able to add a feature because it might break the AAX format. That won’t go over well).
Second, I suggest identifying the common/required pieces of data. These should be the basis of your format.Â
Additionally, we must make allowances for additional game-specific data to ride along in the document. So if there is an XML element for a particular infantry unit that contains just a “location” as a territory, games like TripleA can include extensions such as number-of-spaces-moved and TripleA and MapView both can attach things like X/Y coordinates. This data should be maintained through the import/export process. An example: For MapView, a game id is required because MapView supports many types of games. So if a MapView game is exported into an AAX file and then imported into a TripleA game, that game id should be re-outputed when the game exported.Â
(It’s worth noting that the “game id” mebtioned above might not actually be needed since other header information in the “generic/common” sections of the AAX are likely to be enough to identify the game as an A&A game. But it illustrates the concept).
Feedback to these ideas?
Mot
-
Hey at the very least we could supply you with a much better map file for triple A to use than the current one.
-
Sound good.
My thoughts were to have two XML formats. The first, main format, saves the current state of the game. Turn number, game number, current country’s turn, where the units are on the map, how much money each country has, how many IPCs, etc.
The next format would come later, it would be the actual turn that was performed. Units purchased, units moved where, the combat that took place, the results of combat etc. The idea here is that you can apply the actions XML file on the game state XML file and “replay” the actions that your opponent took.
None of the formats “enforce” rules, they simply explain what was done and the results.
Mot, is there any mroe work being done on MapView? Do you have a way to figure out if units are in a territory? OR is it just X,Y coordinates?
-
I’ll pop in here too. I had thoughts about building a web-based game engine to work with my dicey so it would be like DAAK on steroids - eg. not only would it save the player’s e-mail addresses and game ID #, but also how many units/IPCs each country has in each territory etc.
Needless to say, it would get very complicated, and I likely wouldn’t be able to do a visual representation of the game board, at least not without help. But I was also thinking of using some kind of XML file to store the game data.
I was thinking of a structure like this below (ignore any bad syntax). This shows:
- Ukraine controlled by Germany with Ger: 4 INf 2 Arm and Jap: 2 Jet Fighters, and
- Caucasus controlled by Russia with 1 IC 1 AA.
I think in addition to IPC value each territory should list the “native” owner but I’m too lazy now to type that in yet too…
<map><territory name="Ukraine"><ipc_value>3</ipc_value> <owner name="Germany">(or <owner>Germany</owner>?) <units_present><player name="Germany><quantity>4</quantity> <unit name="Tanks"><quantity>2</quantity></unit><br /><unit name=" infantry"=""></player> <player name="Japan"><unit name="Jet Fighter"><quantity>2</quantity></unit></player></units_present></owner></territory> <territory name="Caucasus"><ipc_value>4</ipc_value> <owner name="Russia"><units_present><player name="Russia"><unit name="AA"><quantity>1</quantity></unit> <unit name="IC"><quantity>1</quantity></unit></player></units_present></owner></territory></map>Alternately you could make each unit an individual object with attributes such as just_unloaded_from_transport, num_moves_made, submerged, participated_in_combat, just_built or whatever. Just brainstorming.
-
I’d actually like the main XML file to represent the state of the game between turns. Purely a representation of the map after you finish your turn and before your opponent begins their turn.
I’m going to gather all of these suggestions and formulate an example.
-
I’m going to gather all of these suggestions and formulate an example.
If you build it, they will come! Bring on the prototype, wise leader.
-
I’d actually like the main XML file to represent the state of the game between turns. Purely a representation of the map after you finish your turn and before your opponent begins their turn.
Good call. Much simpler, and all you need to play/save a game.
-
I’d actually like the main XML file to represent the state of the game between turns. Purely a representation of the map after you finish your turn and before your opponent begins their turn.
I’m going to gather all of these suggestions and formulate an example.
I’m inclined to think there might be advantages to refining that time period from a turn to a phase given the mechanics of A&A. I know I’d want to see the combat moves and the non-combat moves.
I think the document should have a few sections:
1. An initial state (locations, unit quantities, players IPCs, turn number, phase of turn, etc).
2. An end state, again locations, unit quantities, players IPCs, turn number, phase of turn, etc.
3. The actions taken to get from the initial state to the end state. (Combat Move 3 Inf From Eastern Europe To Karelia)(The initial and end stat should be discrete and well defined points. There is no need to create a snapshot in the middle a unit’s move. This helps eliminate a lot of the tiny bits of information that might be program-specific).
All this above should be placed into a parent node such that all of these “turns” (which is not a good name because it will actually hold info about less than turn) can be accumulated for the length of the game.Â
The goal should be to capture all the information in a generic way. Whether any current or new program can use that information doesn’t matter. They can ignore pieces that are not meaningful to them.Â
I think I’m up to 4 cents now ;)
Mot -
The begin state and the end state can be the same XML markup. The same definitions.
That’s a good idea about storing the phases of the turn in the “transformations” XML.
Instead of having one universal XML. I’d like 2. The reason being that implementing the current state of the game might be easier for a piece of software to implement than applying the phases during the turns. The state XML would be required to implement to be compatible but the turn XML would be optional. All the turn document is for is to replay or show how did you get from the begin state XML to the end state XML.
-
Again, I’d just make the implementation of some of the sections of the xml document option, not break it into seperate document files. The whole point of the self-describing nature of XML is that you can put them into the same file without harming programs that consume them. Fuller, richer implementations will need them both, so no point in splitting them out.
Mot
-
I just see it as different types of data. One is state data and one is action data. But I see your point.
It might be a little tricky in a PBEM or PBF situation.
-
Perhaps I should take a step back…what is the exact goal that is trying to be accomplished? I came in late to this so I could be trying to accomplish something different. I apologize for not asking this sooner!
I was trying to capture everything needed to play the game via an exchange of the XML document. This obviously includes the “end state” of a turn, but you cannot use the end state alone to actually play a game. If I was playing against someone and it was their turn and they just tried to just send me their end-of-turn game state I’d balk immediately. I’d want to know what they did to create that state. What units performed a comabt move, which ones retreated and where, what were the purchases and where did they get placed. You get the idea.
If the goal is to model the end-of-turn state then it is definately an easier task (and you should ignore a lot of the more advanced suggestions), but the usefulness of such a format gets reduced.
So to sum up, what is the “mssion statement”, the objective we are laboring towards?
Mot
-
Right now the mapping utils seem to only be used for end of state descriptions. But if all the transformations were included in the XML document, you could actually have the mapping util generate your move descriptions (combat movement description, combat description, non-combat movement description, etc.)
We are using TripleA to do this very thing right now, (since it already captures transformations) and I’ll tell you it works really well. Not having to type up your moves every turn leaves a lot more time to actually think about strategy.
Rob
-
I wonder whether the map utilities that currently exist can utilize the new formats well enough.
I’m sure most can be made to render the information, but I don’t know if the infrastructure exists to capture some of the things we are talking about.
This really does come down to what the goal is. There is merit in doing a bare-bones standard to facilite a kind of map conversion and then supplament that information with an outside source as is done today with a lot of the utilities. It’s a tough call.
I suggest we focus on defining the goals first.
Mot
-
Yeah, if you’re not careful you’ll end up re-inventing tripleA, only with a different file format. Or would the idea be to have TripleA start using this file format?
A universal format would be cool. Some players say they can’t use TripleA for whatever reason so if you could save the file and have the other player use MapView to open it, change and save it and send it back - but that would mean a lot of work on Mapview.
-
Yes, it would mean work on Mapview, work on TripleA, and work on any other util that people wanted to use. But it would also mean that everything would be compatible. I think that’s the goal, that I could use TripleA and you could use a physical gameboard and just type in your moves (maybe using a text XML generator).
-
Yea all you really need is a decent map and pieces to shift around. Players can access the dice roller and then delete the units that died and add units they built. The “snapshot” of each players turn could be added to the existing text inventory of movement/combat actions. That way other could follow the game. In some manner the game could be downloaded to view like a slide show turn by turn?
The idea would be to eliminate the need to have a physical board set up.
-
I suggest we focus on defining the goals first.
Mot
Goals, as I see it:
1. Compatibility to make PBEM easier with any client of your choosing
2. Allow different levels of integration with the standard
Requirements
1. Be able to do what is already done by the software today, passing around a map file in forums or email.
2. Eventually, describe the actions performed during the turn.I’m trying to apply incremental development methodology here. Not everybody is going to be able to implement the full standard right away.
What is the first and most important thing? Pass around a map and manually describe your turn like MapView and ABattleMap today.
What is the best thing? Describe both the map and the actions performed during a turn.Maybe I’m taking the incremental idea too far and injecting too much complexity? Sometimes trying to make it easier can actually have the opposite affect.
Suggested Topics
