using System;
using System.Collections.Generic;
using System.Text;
using Supremacy.Types;
using Supremacy.Entities;
using Supremacy.Data;
using Supremacy.Game;
using Wintellect.PowerCollections;

namespace Supremacy.Universe
{
    [Serializable]
    public sealed class Planet : UniverseObject
    {
        public const int MaxMoonsPerPlanet = 5;
        public const int MaxVariations = 3;

        private const uint PlanetSizeMask = 0xE0000000;
        private const byte PlanetSizeOffset = 29;
        private const uint PlanetTypeMask = 0x1E000000;
        private const byte PlanetTypeOffset = 25;
        private const uint VariationMask = 0x01800000;
        private const byte VariationOffset = 23;
        private const uint MoonCountMask = 0x00700000;
        private const byte MoonCountOffset = 20;
        private const uint MoonDataMask = 0x000FFFFF;
        private const byte MoonDataOffset = 0;
        private const byte MoonDataUnitSize = 4;

        private uint planetData;

        public PlanetType PlanetType
        {
            get
            {
                return (PlanetType)((planetData & PlanetTypeMask) >> PlanetTypeOffset);
            }
            set
            {
                planetData = ((planetData & ~PlanetTypeMask) | (((uint)value << PlanetTypeOffset) & PlanetTypeMask));
                OnPropertyChanged("PlanetType");
                switch (value)
                {
                    case PlanetType.GasGiant:
                        PlanetSize = PlanetSize.GasGiant;
                        break;
                    case PlanetType.Asteroids:
                        PlanetSize = PlanetSize.Asteroids;
                        break;
                    case PlanetType.Rogue:
                        PlanetSize = PlanetSize.Tiny;
                        break;
                }
            }
        }

        public PlanetSize PlanetSize
        {
            get
            {
                return (PlanetSize)((planetData & PlanetSizeMask) >> PlanetSizeOffset);
            }
            set
            {
                if (value == PlanetSize.NoWorld)
                {
                    throw new ArgumentException(
                        "NoWorld is not a valid value for PlanetSize");
                }
                planetData = ((planetData & ~PlanetSizeMask) | (((uint)value << PlanetSizeOffset) & PlanetSizeMask));
                OnPropertyChanged("PlanetSize");
            }
        }

        public int Variation
        {
            get
            {
                return (int)((planetData & VariationMask) >> VariationOffset);
            }
            set
            {
                planetData = ((planetData & ~VariationMask) | (((uint)value << VariationOffset) & VariationMask));
                OnPropertyChanged("Variation");
            }
        }

        public MoonType[] Moons
        {
            get
            {
                uint count = ((planetData & MoonCountMask) >> MoonCountOffset);
                uint moonData = ((planetData & MoonDataMask) >> MoonDataOffset);
                MoonType[] moons = new MoonType[count];
                for (int i = 0; i < count; i++)
                {
                    moons[i] = (MoonType)(moonData >> (MoonDataUnitSize * i));
                }
                return moons;
            }
            internal set
            {
                uint newPlanetData = (planetData & ~MoonDataMask);
                if (value == null)
                {
                    value = new MoonType[0];
                }
                else if (value.Length > MaxMoonsPerPlanet)
                {
                    throw new ArgumentException(
                        "Number of moons must be <= " + MaxMoonsPerPlanet);
                }
                if (value.Length > 0)
                {
                    value = Algorithms.Sort<MoonType>(value,
                        new Comparison<MoonType>(
                        delegate(MoonType a, MoonType b)
                        {
                            return ((int)MoonHelper.GetSize(a)).CompareTo((int)MoonHelper.GetSize(b));
                        }));
                    Array.Reverse(value);
                }
                newPlanetData |= (((uint)value.Length << MoonCountOffset) & MoonCountMask);
                for (int i = 0; i < value.Length; i++)
                {
                    newPlanetData |= ((uint)value[i] << (MoonDataUnitSize * i));
                }
                planetData = newPlanetData;
            }
        }

        public Planet()
            : base()
        {
        }

        public PlanetEnvironment GetEnvironment(Race race)
        {
            switch (this.PlanetType)
            {
                case PlanetType.Asteroids:
                case PlanetType.GasGiant:
                case PlanetType.Crystalline:
                case PlanetType.Demon:
                    return PlanetEnvironment.Uninhabitable;

                case PlanetType.Rogue:
                    return PlanetEnvironment.Terrible;

                default:
                    int result;
                    Wheel<PlanetType> envs = new Wheel<PlanetType>();
                    for (int i = 0; i < (int)PlanetType.Rogue; i++)
                        envs.Insert((PlanetType)i);
                    result = envs.GetDistance(
                        this.PlanetType,
                        race.HomePlanetType);
                    if (result >= (int)PlanetEnvironment.Uninhabitable)
                        return PlanetEnvironment.Uninhabitable;
                    return (PlanetEnvironment)result;
            }
        }

        public bool IsHabitable(Race race)
        {
            return (GetEnvironment(race) != PlanetEnvironment.Uninhabitable);
        }

        public int GetMaxPopulation(Race race)
        {
            Table table = UniverseManager.Tables["PlanetMaxPop"];
            return int.Parse(table[this.PlanetSize.ToString()]
                                  [GetEnvironment(race).ToString()]);
        }

        public Percentage GetGrowthRate(Race race)
        {
            Table table = UniverseManager.Tables["PlanetGrowthRate"];
            return float.Parse(table[this.PlanetSize.ToString()]
                                    [GetEnvironment(race).ToString()]);
        }
    }
}

bool blSameSector = false;

            int n = 3;
            blSameSector = Convert.ToBoolean((Convert.ToByte(blSameSector) + n) % 2);

            label1.Text = Convert.ToByte(blSameSector).ToString();

TotalMovement = (n + blSameSector) / 2

blSameSector = (n + blSameSector) / 2