using System;

using Supremacy.Universe;

namespace Supremacy.Game
{
    /// <summary>
    /// Contains the map visibility data for a civilization in the game.
    /// </summary>
    [Serializable]
    public sealed class CivilizationMapData
    {
        /// <summary>
        /// The maximum scan strength value per sector.
        /// </summary>
        private const byte MaxScanStrength = 63;

        /// <summary>
        /// The maximum fuel range value per sector.
        /// </summary>
        private const byte MaxFuelRange = 255;

        /// <summary>
        /// The 'Scanned' value mask;
        /// </summary>
        private const ushort ScannedMask = 0x8000;

        /// <summary>
        /// The 'Explored' value mask;
        /// </summary>
        private const ushort ExploredMask = 0x4000;

        /// <summary>
        /// The 'Scan Strength' value mask;
        /// </summary>
        private const ushort ScanStrengthMask = 0x3F00;

        /// <summary>
        /// The 'Fuel Range' value mask;
        /// </summary>
        private const ushort FuelRangeMask = 0x00FF;

        /// <summary>
        /// The 'Scan Strength' value offset;
        /// </summary>
        private const byte ScanStrengthOffset = 8;

        /// <summary>
        /// The 'Fuel Range' value offset;
        /// </summary>
        private const byte FuelRangeOffset = 0;

        private ushort[,] _mapData;

        /// <summary>
        /// Initializes a new instance of the <see cref="CivilizationMapData"/> class.
        /// </summary>
        /// <param name="gameMap">The game map.</param>
        public CivilizationMapData(SectorMap gameMap)
        {
            if (gameMap == null)
                throw new ArgumentNullException("gameMap");
            _mapData = new ushort[gameMap.Width, gameMap.Height];
        }

        /// <summary>
        /// Determines whether the specified location is explored.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <returns>
        /// <c>true</c> if the specified location is explored; otherwise, <c>false</c>.
        /// </returns>
        public bool IsExplored(MapLocation location)
        {
            return ((_mapData[location.X, location.Y] & ExploredMask) == ExploredMask);
        }

        /// <summary>
        /// Determines whether the specified location has been scanned.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <returns>
        /// <c>true</c> if the specified location has been scanned; otherwise, <c>false</c>.
        /// </returns>
        public bool IsScanned(MapLocation location)
        {
            return ((_mapData[location.X, location.Y] & ScannedMask) == ScannedMask);
        }

        /// <summary>
        /// Gets the scan strength at the specified location.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <returns>The scan strength.</returns>
        public int GetScanStrength(MapLocation location)
        {
            return ((_mapData[location.X, location.Y] & ScanStrengthMask) >> ScanStrengthOffset);
        }

        /// <summary>
        /// Gets the fuel range at the specified location.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <returns>The fuel range.</returns>
        public int GetFuelRange(MapLocation location)
        {
            return ((_mapData[location.X, location.Y] & FuelRangeMask) >> FuelRangeOffset);
        }

        /// <summary>
        /// Determines whether the specified sector is explored.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <returns>
        /// <c>true</c> if the specified sector is explored; otherwise, <c>false</c>.
        /// </returns>
        public bool IsExplored(Sector sector)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            return IsExplored(sector.Location);
        }

        /// <summary>
        /// Determines whether the specified sector has been scanned.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <returns>
        /// <c>true</c> if the specified sector has been scanned; otherwise, <c>false</c>.
        /// </returns>
        public bool IsScanned(Sector sector)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            return IsScanned(sector.Location);
        }

        /// <summary>
        /// Gets the scan strength at the specified location.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <returns>The scan strength.</returns>
        public int GetScanStrength(Sector sector)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            return GetScanStrength(sector.Location);
        }

        /// <summary>
        /// Gets the fuel range at the specified location.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <returns>The fuel range.</returns>
        public int GetFuelRange(Sector sector)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            return GetFuelRange(sector.Location);
        }

        /// <summary>
        /// Sets whether the specified location has been explored.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">Whether the specified location has been explored.</param>
        public void SetExplored(MapLocation location, bool value)
        {
            if (value)
            {
                SetScanned(location, true);
                _mapData[location.X, location.Y] |= ExploredMask;
            }
            else
            {
                _mapData[location.X, location.Y] =
                    (ushort)(_mapData[location.X, location.Y] & ~ExploredMask);
            }
        }

        /// <summary>
        /// Sets whether the specified location has been scanned.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">Whether the specified location has been scanned.</param>
        public void SetScanned(MapLocation location, bool value)
        {
            if (value)
            {
                _mapData[location.X, location.Y] |= ScannedMask;
            }
            else
            {
                _mapData[location.X, location.Y] =
                    (ushort)(_mapData[location.X, location.Y] & ~ScannedMask);
            }
        }

        /// <summary>
        /// Sets the scan strength at the specified location.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">The scan strength.</param>
        public void SetScanStrength(MapLocation location, int value)
        {
            ushort newValue = (ushort)Math.Min(value, MaxScanStrength);
            ushort newData = (ushort)(_mapData[location.X, location.Y] & ~ScanStrengthMask);
            newData |= (ushort)(newValue << ScanStrengthOffset);
            _mapData[location.X, location.Y] = newData;
        }

        /// <summary>
        /// Sets the fuel range at the specified location.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">The fuel range.</param>
        public void SetFuelRange(MapLocation location, int value)
        {
            ushort newValue = (ushort)Math.Min(value, MaxFuelRange);
            ushort newData = (ushort)(_mapData[location.X, location.Y] & ~FuelRangeMask);
            newData |= (ushort)(newValue << FuelRangeOffset);
            _mapData[location.X, location.Y] = newData;
        }

        /// <summary>
        /// Sets whether the specified sector has been explored.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <param name="value">Whether the specified sector has been explored.</param>
        public void SetExplored(Sector sector, bool value)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            SetExplored(sector.Location, value);
        }

        /// <summary>
        /// Sets whether the specified sector has been scanned.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <param name="value">Whether the specified sector has been scanned.</param>
        public void SetScanned(Sector sector, bool value)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            SetScanned(sector.Location, value);
        }

        /// <summary>
        /// Sets the scan strength at the specified sector.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <param name="value">The scan strength.</param>
        public void SetScanStrength(Sector sector, int value)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            SetScanStrength(sector.Location, value);
        }

        /// <summary>
        /// Sets the fuel range at the specified sector.
        /// </summary>
        /// <param name="sector">The sector.</param>
        /// <param name="value">The fuel range.</param>
        public void SetFuelRange(Sector sector, int value)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            SetFuelRange(sector.Location, value);
        }

        /// <summary>
        /// Resets the scan strength and fuel range for all sectors.
        /// </summary>
        public void ResetScanStrengthAndFuelRange()
        {
            for (int x = 0; x < _mapData.GetLength(0); x++)
            {
                for (int y = 0; y < _mapData.GetLength(1); y++)
                {
                    SetScanStrength(new MapLocation(x, y), 0);
                    SetFuelRange(new MapLocation(x, y), MaxFuelRange);
                }
            }
        }

        /// <summary>
        /// Sets whether the sectors within a specified radius of a given location
        /// have been explored.
        /// </summary>
        /// <param name="location">The origin location.</param>
        /// <param name="value">Whether or not the sectors have been explored.</param>
        /// <param name="radius">The radius.</param>
        public void SetExplored(MapLocation location, bool value, int radius)
        {
            int startX = Math.Max(0, location.X - radius);
            int startY = Math.Max(0, location.Y - radius);
            int endX = Math.Min(_mapData.GetLength(0) - 1, location.X + radius);
            int endY = Math.Min(_mapData.GetLength(1) - 1, location.Y + radius);
            for (int x = startX; x <= endX; x++)
            {
                for (int y = startY; y <= endY; y++)
                {
                    SetExplored(new MapLocation(x, y), value);
                }
            }
        }

        /// <summary>
        /// Sets whether the sectors within a specified radius of a given location
        /// have been scanned.
        /// </summary>
        /// <param name="location">The origin location.</param>
        /// <param name="value">Whether or not the sectors have been scanned.</param>
        /// <param name="radius">The radius.</param>
        public void SetScanned(MapLocation location, bool value, int radius)
        {
            int startX = Math.Max(0, location.X - radius);
            int startY = Math.Max(0, location.Y - radius);
            int endX = Math.Min(_mapData.GetLength(0) - 1, location.X + radius);
            int endY = Math.Min(_mapData.GetLength(1) - 1, location.Y + radius);
            for (int x = startX; x <= endX; x++)
            {
                for (int y = startY; y <= endY; y++)
                {
                    SetScanned(new MapLocation(x, y), value);
                }
            }
        }

        /// <summary>
        /// Sets whether the sectors within a specified radius of a given sector
        /// have been explored.
        /// </summary>
        /// <param name="sector">The origin sector.</param>
        /// <param name="value">Whether or not the sectors have been explored.</param>
        /// <param name="radius">The radius.</param>
        public void SetExplored(Sector sector, bool value, int radius)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            SetExplored(sector.Location, value, radius);
        }

        /// <summary>
        /// Sets whether the sectors within a specified radius of a given sector
        /// have been scanned.
        /// </summary>
        /// <param name="sector">The origin sector.</param>
        /// <param name="value">Whether or not the sectors have been scanned.</param>
        /// <param name="radius">The radius.</param>
        public void SetScanned(Sector sector, bool value, int radius)
        {
            if (sector == null)
                throw new ArgumentNullException("sector");
            SetScanned(sector.Location, value, radius);
        }

        /// <summary>
        /// Upgrades the scan strength at the specified location to a given value.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">The value.</param>
        public void UpgradeScanStrength(MapLocation location, int value)
        {
            if (value > GetScanStrength(location))
                SetScanStrength(location, value);
        }

        /// <summary>
        /// Upgrades the fuel range at the specified location to a given value.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">The value.</param>
        public void UpgradeFuelRange(MapLocation location, int value)
        {
            if (value < GetFuelRange(location))
                SetFuelRange(location, value);
        }

        /// <summary>
        /// Upgrades the scan strength of all sectors within a given radius of the origin location to a given value.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">The value.</param>
        /// <param name="radius">The radius.</param>
        public void UpgradeScanStrength(MapLocation location, int value, int radius)
        {
            int startX = Math.Max(0, location.X - radius);
            int startY = Math.Max(0, location.Y - radius);
            int endX = Math.Min(_mapData.GetLength(0) - 1, location.X + radius);
            int endY = Math.Min(_mapData.GetLength(1) - 1, location.Y + radius);
            for (int x = startX; x <= endX; x++)
            {
                for (int y = startY; y <= endY; y++)
                {
                    UpgradeScanStrength(
                        new MapLocation(x, y),
                        value);
                }
            }
        }

        /// <summary>
        /// Upgrades the scan strength of all sectors within a given radius of the origin location to a given value.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">The value.</param>
        /// <param name="radius">The radius.</param>
        /// <param name="falloff">The falloff incurred at each step away from the origin.</param>
        /// <param name="minValue">The minimum target value, regardless of falloff.</param>
        public void UpgradeScanStrength(MapLocation location, int value, int radius, int falloff, int minValue)
        {
            int startX = Math.Max(0, location.X - radius);
            int startY = Math.Max(0, location.Y - radius);
            int endX = Math.Min(_mapData.GetLength(0) - 1, location.X + radius);
            int endY = Math.Min(_mapData.GetLength(1) - 1, location.Y + radius);
            falloff = Math.Abs(falloff);
            for (int x = startX; x <= endX; x++)
            {
                for (int y = startY; y <= endY; y++)
                {
                    MapLocation targetLocation = new MapLocation(x, y);
                    UpgradeScanStrength(
                        targetLocation,
                        Math.Max(minValue, value - (falloff * MapLocation.GetDistance(location, targetLocation))));
                }
            }
        }

        /// <summary>
        /// Upgrades the fuel range of all sectors within a given radius of the origin location to a given value.
        /// </summary>
        /// <param name="location">The location.</param>
        /// <param name="value">The value.</param>
        /// <param name="radius">The radius.</param>
        public void UpgradeFuelRange(MapLocation location, int value, int radius)
        {
            int startX = Math.Max(0, location.X - radius);
            int startY = Math.Max(0, location.Y - radius);
            int endX = Math.Min(_mapData.GetLength(0) - 1, location.X + radius);
            int endY = Math.Min(_mapData.GetLength(1) - 1, location.Y + radius);
            for (int x = startX; x <= endX; x++)
            {
                for (int y = startY; y <= endY; y++)
                {
                    UpgradeFuelRange(new MapLocation(x, y), value);
                }
            }
        }
    }
}

<?xml version="1.0" encoding="utf-8"?>
<TechTree>
  <Fields>
    <Field>
      <FieldName>Computers</FieldName>
      <FieldDescription>This field is dedicated to compter related research, including new ways of storing and manipulating data as well as security and other related items.</FieldDescription>
      <Techs>
        <Tech>
          <TechName>Bio-Electric Computers</TechName>
          <TechDescription>Tech Description Here</TechDescription>
          <TechType>Developmental</TechType>
          <ResearchCost>5000</ResearchCost>
          <Level>3</Level>
          <TechRequirements>
            <FieldName>Energy</FieldName>
            <TechLevel>1</TechLevel>
          </TechRequirements>
          <TechRequirements>
            <FieldName>Biology</FieldName>
            <TechLevel>3</TechLevel>
          </TechRequirements>
        </Tech>
      </Techs>
    </Field>
    <Field>
      <FieldName>Energy</FieldName>
      <FieldDescription>This Field is dedicated to creating and developing new ways to harness energy to power everything.</FieldDescription>
      <Techs>
        <Tech>
          <TechName>Fusion Power</TechName>
          <TechDescription>Fusion based power research</TechDescription>
          <TechType>Theory</TechType>
          <ResearchCost>100</ResearchCost>
          <Level>1</Level>
        </Tech>
      </Techs>
    </Field>
  </Fields>
</TechTree>

<TechCategory ID="COMPUTERS">
  <Tech ID="COMP_BASIC_THEORY">
    <Name>Basic Computer Theory</Name>
    <Description>This is the basic theory of computers.</Description>
    <Image>Resources/TechImages/comp_basic_theory.png</Image>
    <TechType>Theory</TechType>
    <ResearchCost>100</ResearchCost>
    <Dependencies/>
  </Tech>
  <Tech ID="COMP_BASIC_APP">
    <Name>Basic Computer Application</Name>
    <Description>This allows development of actual basic computers.</Description>
    <Image>Resources/TechImages/comp_basic_app.png</Image>
    <TechType>Application</TechType>
    <ResearchCost>200</ResearchCost>
    <Dependencies>
      <Dependency>COMP_BASIC_THEORY</Dependency>
    </Dependencies>
  </Tech>
</TechCategory>

    <Prerequisites>
      <Prerequisite>COMP_BASIC_THEORY</Prerequisite>
    </Prerequisites>

    <Dependencies>
      <Dependency>SCI_BUILDING_SPECIAL_5</Dependency>
    </Dependencies>

<Buildings>
  <BuildingCategory ID="PROD_FOOD">
  <Building>
    <BuildingName>Simple Farm</BuildingName>
    <BuildingOutput>15</BuildingOutput>
    <BuildCost>20</BuildCost>
    <BuildingRequirements>
      <PowerRequirements>
        <PoweredBy>Population</PoweredBy>
        <Units>1</Units>
      </PowerRequirements>
      <PowerRequirements>
        <PoweredBy>Energy</PoweredBy>
        <Units>1</Units>
      </PowerRequirements>
      <TechRequirements>
        <TechName>Biology</TechName>
        <TechNumber>0</TechNumber>
      </TechRequirements>
      <TechRequirements>
        <TechName>Construction</TechName>
        <TechNumber>0</TechNumber>
      </TechRequirements>
    </BuildingRequirements>
  </Building>
  </BuildingCategory>
</Buildings>

<ModuleCategory ID="Weapons">
  <Module>
    <ModuleName>Nuclear Torpedo</ModuleName>
    <ModuleType>Torpedo</ModuleType>
    <ModuleProperties>
      <DamageModifier>10</DamageModifier>
      <DamageType>Impact</DamageType>
      <Speed>10</Speed>
      <Range>10000</Range>
      <Tracking>0</Tracking>
      <Accuracy>5</Accuracy>
      <DamageToShields>1</DamageToShields>
      <DamageToHull>35</DamageToHull>
      <TotalNumberOfShots>5</TotalNumberOfShots>
      <ShotsPerRound>1</ShotsPerRound>
    </ModuleProperties>
  </Module>
  <Module>
    <ModuleName>Laser Cannon</ModuleName>
    <ModuleType>Beam</ModuleType>
    <ModuleProperties>
      <DamageModifier>2</DamageModifier>
      <DamageType>Energy</DamageType>
      <Range>2000</Range>
      <Tracking>15</Tracking>
      <Accuracy>25</Accuracy>
      <DamageToShields>25</DamageToShields>
      <DamageToHull>5</DamageToHull>
      <ShotsPerRound>5</ShotsPerRound>
    </ModuleProperties>
  </Module>

<Modules>
    <WeaponModules>
        <WeaponModule ... />
        <WeaponModule ... />
    </WeaponModules>
    <ShieldModules>
        <ShieldModule ... />
        <ShieldModule ... />
    </ShieldModules>
    ...
</Modules>

<?xml version="1.0" encoding="utf-8"?>
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:simpleType name="TechType">
    <xs:restriction base="xs:string">
      <xs:enumeration value="Prototype" />
      <xs:enumeration value="Theory" />
      <xs:enumeration value="Application" />
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="Tech">
    <xs:sequence>
      <xs:sequence>
        <xs:element name="Name" type="xs:string" />
        <xs:element name="Description" type="xs:string" />
        <xs:element name="Image" type="xs:string" />
        <xs:element name="TechType" type="TechType" />
        <xs:element name="ResearchCost" type="xs:unsignedShort" />
        <xs:element name="Prerequisite" type="xs:string" minOccurs="0" />
        <xs:element name="Dependency" type="xs:string" minOccurs="0" />
      </xs:sequence>
    </xs:sequence>
    <xs:attribute ref="ID" use="required" />
  </xs:complexType>
  <xs:element name="Research">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="Tech" type="Tech" maxOccurs="unbounded" />
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:attribute name="ID" type="xs:string" />
</xs:schema>

<?xml version="1.0" encoding="utf-8" ?>
<xs:schema id="Techs"
           targetNamespace="GameName:Techs.xsd"
           attributeFormDefault="unqualified"
           elementFormDefault="qualified"
           xmlns="GameName:Techs.xsd"
           xmlns:local="GameName:Techs.xsd"
           xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:simpleType name="TechType">
    <xs:restriction base="xs:NCName">
      <xs:enumeration value="Prototype"/>
      <xs:enumeration value="Theory"/>
      <xs:enumeration value="Application"/>
    </xs:restriction>
  </xs:simpleType>
  <xs:complexType name="TechCategory">
    <xs:sequence>
      <xs:sequence>
        <xs:element name="Name"
                    type="xs:normalizedString"/>
        <xs:element name="Description"
                    type="xs:normalizedString"/>
        <xs:element name="Image"
                    type="xs:normalizedString"/>
      </xs:sequence>
    </xs:sequence>
    <xs:attribute name="Key"
                  use="required"
                  type="xs:NCName"/>
  </xs:complexType>
  <xs:complexType name="Tech">
    <xs:sequence>
      <xs:sequence>
        <xs:element name="Name"
                    type="xs:normalizedString"/>
        <xs:element name="Description"
                    type="xs:normalizedString"/>
        <xs:element name="Category"
                    type="xs:NCName">
        </xs:element>
        <xs:element name="TechType"
                    type="local:TechType"/>
        <xs:element name="Image"
                    type="xs:normalizedString"/>
        <xs:element name="ResearchCost"
                    type="xs:nonNegativeInteger"/>
        <xs:element name="Prerequisites"
                    minOccurs="0">
          <xs:complexType>
            <xs:sequence minOccurs="0">
              <xs:element name="Prerequisite"
                          type="xs:NCName"
                          minOccurs="0"
                          maxOccurs="unbounded"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="UnlockedItems"
                    minOccurs="0">
          <xs:complexType>
            <xs:sequence minOccurs="0">
              <xs:element name="UnlockedItem"
                          type="xs:normalizedString"
                          minOccurs="0"
                          maxOccurs="unbounded"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:sequence>
    <xs:attribute name="Key"
                  use="required"
                  type="xs:NCName"/>
  </xs:complexType>
  <xs:element name="TechTree">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="TechCategories">
          <xs:complexType>
            <xs:sequence minOccurs="0">
              <xs:element name="TechCategory"
                          type="local:TechCategory"
                          minOccurs="0"
                          maxOccurs="unbounded"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="Techs">
          <xs:complexType>
            <xs:sequence minOccurs="0">
              <xs:element name="Tech"
                          type="local:Tech"
                          minOccurs="0"
                          maxOccurs="unbounded"/>
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:sequence>
    </xs:complexType>
    <xs:key name="techCategoryKey">
      <xs:selector xpath="local:TechCategories/local:TechCategory"/>
      <xs:field xpath="@Key"/>
    </xs:key>
    <xs:keyref name="techCategoryKeyRef"
               refer="techCategoryKey">
      <xs:selector xpath="local:Techs/local:Tech"/>
      <xs:field xpath="local:Category"/>
    </xs:keyref>
    <xs:key name="techKey">
      <xs:selector xpath="local:Techs/local:Tech"/>
      <xs:field xpath="@Key"/>
    </xs:key>
    <xs:keyref name="prerequisiteTechKeyRef"
               refer="techKey">
      <xs:selector xpath="local:Techs/local:Tech/local:Prerequisites"/>
      <xs:field xpath="local:Prerequisite"/>
    </xs:keyref>
  </xs:element>
</xs:schema>

<?xml version="1.0" encoding="utf-8" ?>
<TechTree xmlns="GameName:Techs.xsd">
  <TechCategories>
    <TechCategory Key="Computers">
      <Name>Computers</Name>
      <Description>Technologies related to Computers</Description>
      <Image>Resources/Images/TechCategories/Computers.png</Image>
    </TechCategory>
  </TechCategories>
  <Techs>
    <Tech Key="BasicComputers">
      <Name>Basic Computers</Name>
      <Description>Basic computer theory.</Description>
      <Category>Computers</Category>
      <TechType>Theory</TechType>
      <Image>Resources/Images/Techs/BasicComputers.png</Image>
      <ResearchCost>500</ResearchCost>
    </Tech>
    <Tech Key="Microcomputers">
      <Name>Microcomputers</Name>
      <Description>Basic microcomputer production.</Description>
      <Category>Computers</Category>
      <TechType>Application</TechType>
      <Image>Resources/Images/Techs/Microcomputers.png</Image>
      <ResearchCost>1000</ResearchCost>
      <Prerequisites>
        <Prerequisite>BasicComputers</Prerequisite>
      </Prerequisites>
    </Tech>
  </Techs>
</TechTree>