public static Float3 GetNearestReclaim(Float3 mypos, int constructorid)
 {
     if( CSAI.GetInstance().aicallback.GetCurrentFrame() == 0 )// check ticks first, beacuse metal shows as zero at start
     {
         return null;
     }
     LogFile logfile = LogFile.GetInstance();
     IAICallback aicallback = CSAI.GetInstance().aicallback;
     IUnitDef unitdef = UnitController.GetInstance().UnitDefByDeployedId[ constructorid ];
     if (!new UnitDefHelp(aicallback).IsMobile(unitdef))
     {
         return null;
     }
     //Float3 mypos = aicallback.GetUnitPos( constructorid );
     MovementMaps movementmaps = MovementMaps.GetInstance();
     int currentarea = movementmaps.GetArea( unitdef, mypos );
     //double nearestreclaimdistancesquared = 1000000;
     //Float3 nearestreclaimpos = null;
     double bestmetaldistanceratio = 0;
     int bestreclaimid = 0;
     int metalspace = (int)( aicallback.GetMetalStorage() - aicallback.GetMetal() );
     logfile.WriteLine( "available space in metal storage: " + metalspace );
     int[] nearbyfeatures = aicallback.GetFeatures( mypos, maxreclaimradius );
     bool reclaimfound = false;
     foreach( int feature in nearbyfeatures )
     {
         IFeatureDef featuredef = aicallback.GetFeatureDef( feature );
         if( featuredef.metal > 0 && featuredef.metal <= metalspace  )
         {
             Float3 thisfeaturepos = aicallback.GetFeaturePos( feature );
             double thisdistance = Math.Sqrt( Float3Helper.GetSquaredDistance( thisfeaturepos, mypos ) );
             double thismetaldistanceratio = featuredef.metal / thisdistance;
             if( thismetaldistanceratio > bestmetaldistanceratio && movementmaps.GetArea( unitdef, thisfeaturepos ) == currentarea )
             {
                 logfile.WriteLine( "Potential reclaim, distance = " + thisdistance + " metal = " + featuredef.metal + " ratio = " + thismetaldistanceratio );
                 bestmetaldistanceratio = thismetaldistanceratio;
                 bestreclaimid = feature;
        //         nearestreclaimpo
                 reclaimfound = true;
             }
         }
     }
     if( reclaimfound && ( bestmetaldistanceratio > ( 1.0 / ( 100 * reclaimradiusperonehundredmetal ) ) ) )
     {
         Float3 reclaimpos = aicallback.GetFeaturePos( bestreclaimid );
         logfile.WriteLine( "Reclaim found, pos " + reclaimpos.ToString() );
         if( CSAI.GetInstance().DebugOn )
         {
             aicallback.DrawUnit( "ARMMEX", reclaimpos, 0.0f, 200, aicallback.GetMyAllyTeam(), true, true);
         }
         return reclaimpos;
         //aicallback.GiveOrder( constructorid, new Command( Command.CMD_RECLAIM,
         //    new double[]{ reclaimpos.x, reclaimpos.y, reclaimpos.z, 10 } ) );
     }
     else
     {
         //logfile.WriteLine( "No reclaim within parameters" );
         return null;
     }
 }
Exemple #2
0
 public static Float3 operator *( double multiplier, Float3 a )
 {
     Float3 result = new Float3();
     result.x = a.x * multiplier;
     result.y = a.y * multiplier;
     result.z = a.z * multiplier;
     return result;
 }
 public static Float3 operator-( Float3 a, Float3 b )
 {
     Float3 result = new Float3();
     result.x = a.x - b.x;
     result.y = a.y - b.y;
     result.z = a.z - b.z;
     return result;
 }
        // cheap hack to respond to enemy shooting us
        void csai_UnitDamagedEvent(int damaged, int attacker, float damage, Float3 dir)
        {
            /*
            if (!EnemyUnitDefByDeployedId.ContainsKey(attacker))
            {
                EnemyUnitDefByDeployedId.Add(attacker, aicallback.GetUnitDef(attacker));
            }
             */
            //if (!EnemyStaticPosByDeployedId.ContainsKey(attacker))
            //{
            Float3 enemypos = aicallback.GetUnitPos(attacker);
            if (enemypos != null &&
                Float3Helper.GetSquaredDistance(enemypos, new Float3(0, 0, 0)) > 10 * 10)
            {
                logfile.WriteLine("unitdamaged, attacker " + attacker + " pos " + enemypos);
                if (!EnemyStaticPosByDeployedId.ContainsKey(attacker))
                {
                    EnemyStaticPosByDeployedId.Add(attacker, enemypos);
                }
                else
                {
                    EnemyStaticPosByDeployedId[attacker] = enemypos;
                }
                if (NewStaticEnemyAddedEvent != null)
                {
                    NewStaticEnemyAddedEvent(attacker, enemypos, null);
                }
            }
            else // else we guess...
            {
                if (FriendlyUnitPositionObserver.GetInstance().PosById.ContainsKey(damaged))
                {
                    Float3 ourunitpos = FriendlyUnitPositionObserver.GetInstance().PosById[damaged];
                    if (ourunitpos != null)
                    {
                        Float3 guessvectortotarget = dir * 300.0;
                        logfile.WriteLine("vectortotarget guess: " + guessvectortotarget.ToString());
                        Float3 possiblepos = ourunitpos + guessvectortotarget;

                        if (!EnemyStaticPosByDeployedId.ContainsKey(attacker))
                        {
                            EnemyStaticPosByDeployedId.Add(attacker, possiblepos);
                        }
                        else
                        {
                            EnemyStaticPosByDeployedId[attacker] = possiblepos;
                        }

                        if (NewStaticEnemyAddedEvent != null)
                        {
                            NewStaticEnemyAddedEvent(attacker, possiblepos, null);
                        }
                        logfile.WriteLine("unitdamaged, attacker " + attacker + " our unit pos " + ourunitpos + " dir " + dir.ToString() + " guess: " + possiblepos.ToString());
                    }
                }
            }
            //}
        }
 void UnitCreatedEvent(int deployedunitid, IUnitDef unitdef)
 {
     IAICallback aicallback = CSAI.GetInstance().aicallback;
     if (aicallback.GetCurrentFrame() <= 1)
     {
         if (unitdef.isCommander)
         {
             startposition = aicallback.GetUnitPos(deployedunitid);
             //aicallback.get
         }
     }
 }
 public static void DrawCircle( Float3 pos, double radius )
 {
     IAICallback aicallback = CSAI.GetInstance().aicallback;
     Float3 lastpos = null;
     for( int angle = 0; angle <= 360; angle += 10 )
     {
         int x = (int)( (double)radius * Math.Cos ( (double)angle * Math.PI / 180 ) );
         int y = (int)( (double)radius * Math.Sin ( (double)angle * Math.PI / 180 ) );
         Float3 thispos = new Float3( x, 0, y ) + pos;
         if( lastpos != null )
         {
             aicallback.CreateLineFigure( thispos,lastpos,10,false,200,0);
         }
         lastpos = thispos;
     }
 }
Exemple #7
0
 public void SetTarget(Float3 target)
 {
     //this.targetid = targetid;
     //Activate();
 }
 public void SetTarget( Float3 target )
 {
     //this.targetid = targetid;
     //Activate();
 }
Exemple #9
0
 public static double GetSquaredDistance( Float3 one, Float3 two )
 {
     return ( two.x - one.x ) * ( two.x - one.x ) + ( two.y - one.y ) * ( two.y - one.y ) + ( two.z - one.z ) * ( two.z - one.z );
 }
 UnitInfo[] GetClosestUnits( Hashtable UnitDefListByDeployedId, Float3 targetpos, int numclosestunits )
 {
     UnitInfo[] closestunits = new UnitInfo[ numclosestunits ];
     double worsttopfivesquareddistance = 0; // got to get better than this to enter the list
     int numclosestunitsfound = 0;
     foreach( DictionaryEntry de in UnitDefListByDeployedId )
     {
         int deployedid = (int)de.Key;
         IUnitDef unitdef = de.Value as IUnitDef;
         Float3 unitpos = aicallback.GetUnitPos( deployedid );
         double unitsquareddistance = Float3Helper.GetSquaredDistance( unitpos, targetpos );
         if( numclosestunitsfound < numclosestunits )
         {
             UnitInfo unitinfo = new UnitInfo( deployedid, unitpos, unitdef, unitsquareddistance );
             InsertIntoArray( closestunits, unitinfo, numclosestunitsfound );
             numclosestunitsfound++;
             worsttopfivesquareddistance = closestunits[ numclosestunitsfound - 1 ].squareddistance;
         }
         else if( unitsquareddistance < worsttopfivesquareddistance )
         {
             UnitInfo unitinfo = new UnitInfo( deployedid, unitpos, unitdef, unitsquareddistance );
             InsertIntoArray( closestunits, unitinfo, numclosestunits );
             worsttopfivesquareddistance = closestunits[ numclosestunits - 1 ].squareddistance;
         }
     }
     return closestunits;
 }
Exemple #11
0
        UnitInfo[] GetClosestUnits(Dictionary <int, IUnitDef> UnitDefListByDeployedId, Float3 targetpos, int numclosestunits)
        {
            UnitInfo[] closestunits = new UnitInfo[numclosestunits];
            double     worsttopfivesquareddistance = 0; // got to get better than this to enter the list
            int        numclosestunitsfound        = 0;

            foreach (KeyValuePair <int, IUnitDef> kvp in UnitDefListByDeployedId)
            {
                int      deployedid          = kvp.Key;
                IUnitDef unitdef             = kvp.Value;
                Float3   unitpos             = aicallback.GetUnitPos(deployedid);
                double   unitsquareddistance = Float3Helper.GetSquaredDistance(unitpos, targetpos);
                if (numclosestunitsfound < numclosestunits)
                {
                    UnitInfo unitinfo = new UnitInfo(deployedid, unitpos, unitdef, unitsquareddistance);
                    InsertIntoArray(closestunits, unitinfo, numclosestunitsfound);
                    numclosestunitsfound++;
                    worsttopfivesquareddistance = closestunits[numclosestunitsfound - 1].squareddistance;
                }
                else if (unitsquareddistance < worsttopfivesquareddistance)
                {
                    UnitInfo unitinfo = new UnitInfo(deployedid, unitpos, unitdef, unitsquareddistance);
                    InsertIntoArray(closestunits, unitinfo, numclosestunits);
                    worsttopfivesquareddistance = closestunits[numclosestunits - 1].squareddistance;
                }
            }
            return(closestunits);
        }
        // note: need to check compatible area
        public Float3 GetNearestUnseen(Float3 currentpos, IUnitDef unitdef, int unseensmeansthismanyframes)
        {
            LosMap      losmap     = LosMap.GetInstance();
            IAICallback aicallback = CSAI.GetInstance().aicallback;
            int         mapwidth   = aicallback.GetMapWidth();
            int         mapheight  = aicallback.GetMapHeight();

            int currentunitarea = MovementMaps.GetInstance().GetArea(unitdef, currentpos);
            int losmapwidth     = losmap.LastSeenFrameCount.GetUpperBound(0) + 1;
            int losmapheight    = losmap.LastSeenFrameCount.GetUpperBound(0) + 1;
            int maxradius       = (int)Math.Sqrt(losmapheight * losmapheight + losmapwidth * losmapwidth);
            int unitlosradius   = (int)unitdef.losRadius; // this is in map / 2 units, so it's ok

            Int2[] circlepoints   = CreateCirclePoints(unitlosradius);
            int    bestradius     = 10000000;
            int    bestarea       = 0;
            Float3 bestpos        = null;
            int    unitmapx       = (int)(currentpos.x / 16);
            int    unitmapy       = (int)(currentpos.y / 16);
            int    thisframecount = aicallback.GetCurrentFrame();

            // step around in unitlosradius steps
            for (int radiuslosunits = unitlosradius * 2; radiuslosunits <= maxradius; radiuslosunits += unitlosradius)
            {
                // calculate angle for a unitlosradius / 2 step at this radius.
                // DrawingUtils.DrawCircle(currentpos, radiuslosunits * 16);

                double anglestepradians = 2 * Math.Asin((double)unitlosradius / 2 / (double)radiuslosunits);
                //csai.DebugSay("anglestepradians: " + anglestepradians);
                //return null;
                for (double angleradians = 0; angleradians <= Math.PI * 2; angleradians += anglestepradians)
                {
                    int unseenarea = 0;
                    int searchmapx = unitmapx + (int)((double)radiuslosunits * Math.Cos(angleradians));
                    int searchmapy = unitmapy + (int)((double)radiuslosunits * Math.Sin(angleradians));
                    if (searchmapx >= 0 && searchmapy >= 0 && searchmapx < (mapwidth / 2) && searchmapy < (mapheight / 2))
                    {
                        // if (csai.DebugOn)
                        //  {
                        //      int groupnumber = DrawingUtils.DrawCircle(new Float3(searchmapx * 16, 50 + aicallback.GetElevation( searchmapx * 16, searchmapy * 16 ), searchmapy * 16), unitlosradius * 16);
                        //     aicallback.SetFigureColor(groupnumber, 1, 1, 0, 0.5);
                        // }

                        int thisareanumber = MovementMaps.GetInstance().GetArea(unitdef, new Float3(searchmapx * 16, 0, searchmapy * 16));
                        if (thisareanumber == currentunitarea)
                        {//
                            //if (csai.DebugOn)
                            // {
                            //     int groupnumber = DrawingUtils.DrawCircle(new Float3(searchmapx * 16, 100, searchmapy * 16), unitlosradius * 16);
                            //     aicallback.SetFigureColor(groupnumber, 1, 1, 0, 0.5);
                            // }
                            foreach (Int2 point in circlepoints)
                            {
                                int thismapx = searchmapx + point.x;
                                int thismapy = searchmapy + point.y;
                                if (thismapx >= 0 && thismapy >= 0 && thismapx < mapwidth / 2 && thismapy < mapheight / 2)
                                {
                                    if (thisframecount - losmap.LastSeenFrameCount[thismapx, thismapy] > unseensmeansthismanyframes)
                                    {
                                        unseenarea++;
                                    }
                                }
                            }
                            if (unseenarea >= (circlepoints.GetUpperBound(0) + 1) * 8 / 10)
                            {
                                int groupnumber = DrawingUtils.DrawCircle(new Float3(searchmapx * 16, 100 * aicallback.GetElevation(searchmapx * 16, searchmapy * 16), searchmapy * 16), unitlosradius * 16);
                                aicallback.SetFigureColor(groupnumber, 1, 0, 1, 0.5);
                                return(new Float3(searchmapx * 16, 0, searchmapy * 16));
                            }
                            // return new Float3(searchmapx * 16, 0, searchmapy * 16); // for debugging, remove later
                        }
                    }
                }
            }
            return(null);
        }
Exemple #13
0
 public static void WriteFloat3ToXmlElement(Float3 float3, XmlElement element)
 {
     element.SetAttribute("x", float3.x.ToString());
     element.SetAttribute("y", float3.y.ToString());
     element.SetAttribute("z", float3.z.ToString());
 }
        public IUnitOrder RegisterBuildingOrder(IFactoryController factorycontroller, IUnitDef orderedunittype, Float3 orderedpos)
        {
            Order order = new Order(factorycontroller, orderedunittype, orderedpos);

            orders.Add(order);
            return(order);
        }
 void CommanderBuildAt(IUnitDef unitdef, Float3 buildsite)
 {
     logfile.WriteLine("Commander building " + unitdef.name + " at " + buildsite.ToString());
     aicallback.DrawUnit(unitdef.name, buildsite, 0.0f, 500, aicallback.GetMyAllyTeam(), true, true);
     aicallback.GiveOrder(commanderid, new Command(-unitdef.id, buildsite.ToDoubleArray()));
 }
Exemple #16
0
        // algorithm more or less by krogothe
        // ported from Submarine's original C++ version
        public void SearchMetalSpots()
        {
            logfile.WriteLine("SearchMetalSpots() >>>");

            isMetalMap = false;

            ArrayList metalspotsal = new ArrayList();

            int    mapheight   = aicallback.GetMapHeight() / 2; //metal map has 1/2 resolution of normal map
            int    mapwidth    = aicallback.GetMapWidth() / 2;
            double mapmaxmetal = aicallback.GetMaxMetal();
            int    totalcells  = mapheight * mapwidth;

            logfile.WriteLine("mapwidth: " + mapwidth + " mapheight " + mapheight + " maxmetal:" + mapmaxmetal);

            byte[] metalmap = aicallback.GetMetalMap();                          // original metal map
            int[,] metalremaining               = new int[mapwidth, mapheight];  // actual metal available at that point. we remove metal from this as we add spots to MetalSpots
            int[,] SpotAvailableMetal           = new int [mapwidth, mapheight]; // amount of metal an extractor on this spot could make
            int[,] NormalizedSpotAvailableMetal = new int [mapwidth, mapheight]; // SpotAvailableMetal, normalized to 0-255 range

            int          totalmetal   = 0;
            ArrayIndexer arrayindexer = new ArrayIndexer(mapwidth, mapheight);

            //Load up the metal Values in each pixel
            logfile.WriteLine("width: " + mapwidth + " height: " + mapheight);
            for (int y = 0; y < mapheight; y++)
            {
                //string logline = "";
                for (int x = 0; x < mapwidth; x++)
                {
                    metalremaining[x, y] = (int)metalmap[arrayindexer.GetIndex(x, y)];
                    totalmetal          += metalremaining[x, y];        // Count the total metal so you can work out an average of the whole map
                    //logline += metalremaining[ x, y ].ToString() + " ";
                    //  logline += metalremaining[ x, y ] + " ";
                }
                // logfile.WriteLine( logline );
            }
            logfile.WriteLine("*******************************************");

            double averagemetal = ((double)totalmetal) / ((double)totalcells);  //do the average
            // int maxmetal = 0;

            int    ExtractorRadius           = (int)(aicallback.GetExtractorRadius() / 16.0);
            int    DoubleExtractorRadius     = ExtractorRadius * 2;
            int    SquareExtractorRadius     = ExtractorRadius * ExtractorRadius; //used to speed up loops so no recalculation needed
            int    FourSquareExtractorRadius = 4 * SquareExtractorRadius;         // same as above
            double CellsInRadius             = Math.PI * ExtractorRadius * ExtractorRadius;

            int maxmetalspotamount = 0;

            logfile.WriteLine("Calculating available metal for each spot...");
            SpotAvailableMetal = CalculateAvailableMetalForEachSpot(metalremaining, ExtractorRadius, out maxmetalspotamount);

            logfile.WriteLine("Normalizing...");
            // normalize the metal so any map will have values 0-255, no matter how much metal it has
            int[,] NormalizedMetalRemaining = new int[mapwidth, mapheight];
            for (int y = 0; y < mapheight; y++)
            {
                for (int x = 0; x < mapwidth; x++)
                {
                    NormalizedSpotAvailableMetal[x, y] = (SpotAvailableMetal[x, y] * 255) / maxmetalspotamount;
                }
            }

            logfile.WriteLine("maxmetalspotamount: " + maxmetalspotamount);

            bool Stopme     = false;
            int  SpotsFound = 0;

            //logfile.WriteLine( BuildTable.GetInstance().GetBiggestMexUnit().ToString() );
            // IUnitDef biggestmex = BuildTable.GetInstance().GetBiggestMexUnit();
            // logfile.WriteLine( "biggestmex is " + biggestmex.name + " " + biggestmex.humanName );
            for (int spotindex = 0; spotindex < MaxSpots && !Stopme; spotindex++)
            {
                logfile.WriteLine("spotindex: " + spotindex);
                int bestspotx = 0, bestspoty = 0;
                int actualmetalatbestspot = 0; // use to try to put extractors over spot itself
                //finds the best spot on the map and gets its coords
                int BestNormalizedAvailableSpotAmount = 0;
                for (int y = 0; y < mapheight; y++)
                {
                    for (int x = 0; x < mapwidth; x++)
                    {
                        if (NormalizedSpotAvailableMetal[x, y] > BestNormalizedAvailableSpotAmount ||
                            (NormalizedSpotAvailableMetal[x, y] == BestNormalizedAvailableSpotAmount &&
                             metalremaining[x, y] > actualmetalatbestspot))
                        {
                            BestNormalizedAvailableSpotAmount = NormalizedSpotAvailableMetal[x, y];
                            bestspotx             = x;
                            bestspoty             = y;
                            actualmetalatbestspot = metalremaining[x, y];
                        }
                    }
                }
                logfile.WriteLine("BestNormalizedAvailableSpotAmount: " + BestNormalizedAvailableSpotAmount);
                if (BestNormalizedAvailableSpotAmount < MinMetalForSpot)
                {
                    Stopme = true; // if the spots get too crappy it will stop running the loops to speed it all up
                    logfile.WriteLine("Remaining spots too small; stopping search");
                }

                if (!Stopme)
                {
                    Float3 pos = new Float3();
                    pos.x = bestspotx * 2 * MovementMaps.SQUARE_SIZE;
                    pos.z = bestspoty * 2 * MovementMaps.SQUARE_SIZE;
                    pos.y = aicallback.GetElevation(pos.x, pos.z);

                    //pos = Map.PosToFinalBuildPos( pos, biggestmex );

                    logfile.WriteLine("Metal spot: " + pos + " " + BestNormalizedAvailableSpotAmount);
                    MetalSpot thismetalspot = new MetalSpot((int)((BestNormalizedAvailableSpotAmount * mapmaxmetal * maxmetalspotamount) / 255), pos);

                    //    if (aicallback.CanBuildAt(biggestmex, pos) )
                    //  {
                    // pos = Map.PosToBuildMapPos( pos, biggestmex );
                    // logfile.WriteLine( "Metal spot: " + pos + " " + BestNormalizedAvailableSpotAmount );

                    //     if(pos.z >= 2 && pos.x >= 2 && pos.x < mapwidth -2 && pos.z < mapheight -2)
                    //      {
                    //  if(CanBuildAt(pos.x, pos.z, biggestmex.xsize, biggestmex.ysize))
                    // {
                    metalspotsal.Add(thismetalspot);
                    SpotsFound++;

                    //if(pos.y >= 0)
                    //{
                    // SetBuildMap(pos.x-2, pos.z-2, biggestmex.xsize+4, biggestmex.ysize+4, 1);
                    //}
                    //else
                    //{
                    //SetBuildMap(pos.x-2, pos.z-2, biggestmex.xsize+4, biggestmex.ysize+4, 5);
                    //}
                    //  }
                    //   }
                    //   }

                    for (int myx = bestspotx - (int)ExtractorRadius; myx < bestspotx + (int)ExtractorRadius; myx++)
                    {
                        if (myx >= 0 && myx < mapwidth)
                        {
                            for (int myy = bestspoty - (int)ExtractorRadius; myy < bestspoty + (int)ExtractorRadius; myy++)
                            {
                                if (myy >= 0 && myy < mapheight &&
                                    ((bestspotx - myx) * (bestspotx - myx) + (bestspoty - myy) * (bestspoty - myy)) <= (int)SquareExtractorRadius)
                                {
                                    metalremaining[myx, myy] = 0;   //wipes the metal around the spot so its not counted twice
                                    NormalizedSpotAvailableMetal[myx, myy] = 0;
                                }
                            }
                        }
                    }

                    // Redo the whole averaging process around the picked spot so other spots can be found around it
                    for (int y = bestspoty - (int)DoubleExtractorRadius; y < bestspoty + (int)DoubleExtractorRadius; y++)
                    {
                        if (y >= 0 && y < mapheight)
                        {
                            for (int x = bestspotx - (int)DoubleExtractorRadius; x < bestspotx + (int)DoubleExtractorRadius; x++)
                            {
                                //funcion below is optimized so it will only update spots between r and 2r, greatly speeding it up
                                if ((bestspotx - x) * (bestspotx - x) + (bestspoty - y) * (bestspoty - y) <= (int)FourSquareExtractorRadius &&
                                    x >= 0 && x < mapwidth &&
                                    NormalizedSpotAvailableMetal[x, y] > 0)
                                {
                                    totalmetal = 0;
                                    for (int myx = x - (int)ExtractorRadius; myx < x + (int)ExtractorRadius; myx++)
                                    {
                                        if (myx >= 0 && myx < mapwidth)
                                        {
                                            for (int myy = y - (int)ExtractorRadius; myy < y + (int)ExtractorRadius; myy++)
                                            {
                                                if (myy >= 0 && myy < mapheight &&
                                                    ((x - myx) * (x - myx) + (y - myy) * (y - myy)) <= (int)SquareExtractorRadius)
                                                {
                                                    totalmetal += metalremaining[myx, myy];   //recalculate nearby spots to account for deleted metal from chosen spot
                                                }
                                            }
                                        }
                                    }
                                    NormalizedSpotAvailableMetal[x, y] = totalmetal * 255 / maxmetalspotamount;   //set that spots metal amount
                                }
                            }
                        }
                    }
                }
            }

            if (SpotsFound > 500)
            {
                isMetalMap = true;
                metalspotsal.Clear();
                logfile.WriteLine("Map is considered to be a metal map");
            }
            else
            {
                isMetalMap = false;

                // debug
                //for(list<AAIMetalSpot>::iterator spot = metal_spots.begin(); spot != metal_spots.end(); spot++)
            }

            MetalSpots = ( MetalSpot[] )metalspotsal.ToArray(typeof(MetalSpot));

            SaveCache();
            logfile.WriteLine("SearchMetalSpots() <<<");
        }
 public Order(IFactoryController factorycontroller, IUnitDef orderedunit, Float3 pos)
 {
     this.factorycontroller = factorycontroller;
     this.orderedunit       = orderedunit;
     this.pos = pos;
 }
Exemple #18
0
 public MetalSpot(int amount, Float3 pos, bool isoccupied)
 {
     Amount     = amount;
     IsOccupied = isoccupied;
     Pos        = pos;
 }
Exemple #19
0
 public MetalSpot(int amount, Float3 pos)
 {
     Amount = amount;
     Pos    = pos;
 }
Exemple #20
0
        public Float3 ClosestBuildSite(IUnitDef unitdef, Float3 approximatepos, int maxposradius, int mindistancemapunits)
        {
            // ok, so plan is we work our way out in a kindof spiral
            // we start in centre, and increase radius, and work around in a square at each radius, until we find something
            int centrex = (int)(approximatepos.x / 8);
            int centrey = (int)(approximatepos.z / 8);
            //int radius = 0;
            int radius = mindistancemapunits;
            int unitsizexwithmargin = unitdef.xsize + 2 * BuildMargin;
            int unitsizeywithmargin = unitdef.ysize + 2 * BuildMargin;

            if (unitdefhelp.IsFactory(unitdef))
            {
                unitsizeywithmargin += 8;
                centrey             += 4;
            }
            BuildMap     buildmap     = BuildMap.GetInstance();
            MovementMaps movementmaps = MovementMaps.GetInstance();

            // while( radius < mapwidth || radius < mapheight ) // hopefully we never get quite this far...
            while (radius < (maxposradius / 8))
            {
                //  logfile.WriteLine( "ClosestBuildSite radius " + radius );
                for (int deltax = -radius; deltax <= radius; deltax++)
                {
                    for (int deltay = -radius; deltay <= radius; deltay++)
                    {
                        if (deltax == radius || deltax == -radius || deltay == radius || deltay == -radius)  // ignore the hollow centre of square
                        {
                            // logfile.WriteLine( "delta " + deltax + " " + deltay );
                            bool positionok = true;
                            // go through each square in proposed site, check not build on
                            for (int buildmapy = centrey - unitsizeywithmargin / 2; positionok && buildmapy < centrey + unitsizeywithmargin / 2; buildmapy++)
                            {
                                //string logline = "";
                                for (int buildmapx = centrex - unitsizexwithmargin / 2; positionok && buildmapx < centrex + unitsizexwithmargin / 2; buildmapx++)
                                {
                                    int thisx = buildmapx + deltax;
                                    int thisy = buildmapy + deltay;
                                    if (thisx < 0 || thisy < 0 || thisx >= mapwidth || thisy >= mapwidth ||
                                        !buildmap.SquareAvailable[thisx, thisy] ||
                                        !movementmaps.vehiclemap[thisx / 2, thisy / 2])
                                    {
                                        //logfile.WriteLine( "check square " + buildmapx + " " + buildmapy + " NOK" );
                                        positionok = false;
                                        //   logline += "*";
                                    }
                                    else
                                    {
                                        //   logline += "-";
                                    }
                                    //logfile.WriteLine( "check square " + buildmapx + " " + buildmapy + "Ok" );
                                }
                                //    logfile.WriteLine( logline );
                            }
                            // logfile.WriteLine("");
                            if (positionok)
                            {
                                return(new Float3((centrex + deltax) * 8, 0, (centrey + deltay) * 8));
                            }
                        }
                    }
                }
                radius++;
            }
            return(null);
        }
 void ExploreWith( int unitid )
 {
     Float3 destination = new Float3();
    // if( PriorityTargets.Count > 0 )
    // {            
   //      destination = PriorityTargets.Dequeue() as Float3;
   //      logfile.WriteLine( "dequeued next destination: " + destination.ToString() );
   //  }
   //  else
   //  {
         destination.x = random.Next(0, aicallback.GetMapWidth() * MovementMaps.SQUARE_SIZE );
         destination.z = random.Next( 0, aicallback.GetMapHeight() * MovementMaps.SQUARE_SIZE );
         destination.y = aicallback.GetElevation( destination.x, destination.y );
         logfile.WriteLine( "mapwidth: " + aicallback.GetMapWidth() + " squaresize: " + MovementMaps.SQUARE_SIZE );
         logfile.WriteLine( "ScoutController sending scout " + unitid + " to " + destination.ToString() );
   //  }
     //aicallback.GiveOrder( unitid, new Command( Command.CMD_MOVE, destination.ToDoubleArray() ) );
     GiveOrderWrapper.GetInstance().MoveTo(unitid, destination);
 }
Exemple #22
0
        void Reappraise()
        {
            foreach (DictionaryEntry scoutde in ScoutUnitDefsById)
            {
                int    scoutdeployedid = (int)scoutde.Key;
                Float3 scoutpos        = aicallback.GetUnitPos(scoutdeployedid);

                Float3 nearestpos          = null;
                double bestsquareddistance = 100000000;
                int    targetid            = 0;
                // need to add index by position for this, to speed things up
                foreach (DictionaryEntry de in EnemyController.GetInstance().EnemyUnitDefByDeployedId)
                {
                    int      deployedid = (int)de.Key;
                    IUnitDef unitdef    = de.Value as IUnitDef;
                    if (unitdef != null)
                    {
                        Float3 thispos = aicallback.GetUnitPos(deployedid);
                        if (IsPriorityTarget(unitdef))
                        {
                            double thissquareddistance = Float3Helper.GetSquaredDistance(scoutpos, thispos);
                            if (thissquareddistance < bestsquareddistance)
                            {
                                bool nolasertowersnear = true;
                                foreach (DictionaryEntry attackerde in EnemyController.GetInstance().EnemyUnitDefByDeployedId)
                                {
                                    int      attackerid      = (int)attackerde.Key;
                                    IUnitDef attackerunitdef = attackerde.Value as IUnitDef;
                                    if (attackerunitdef != null)
                                    {
                                        if (IsLaserTower(attackerunitdef))
                                        {
                                            Float3 attackerpos = aicallback.GetUnitPos(attackerid);
                                            if (Float3Helper.GetSquaredDistance(attackerpos, thispos) < nearbyforenemiesmeans * nearbyforenemiesmeans)
                                            {
                                                nolasertowersnear = false;
                                            }
                                        }
                                    }
                                }
                                if (nolasertowersnear)
                                {
                                    nearestpos          = thispos;
                                    bestsquareddistance = thissquareddistance;
                                    targetid            = deployedid;
                                }
                            }
                        }
                    }
                }
                if (nearestpos != null)
                {
                    aicallback.GiveOrder(scoutdeployedid, new Command(Command.CMD_ATTACK, new double[] { targetid }));
                    if (!attackingscouts.Contains(scoutdeployedid))
                    {
                        attackingscouts.Add(scoutdeployedid);
                    }
                }
                else
                {
                    if (attackingscouts.Contains(scoutdeployedid))
                    {
                        ExploreWith(scoutdeployedid);
                        attackingscouts.Remove(scoutdeployedid);
                    }
                }
            }
        }
Exemple #23
0
        void Reappraise()
        {
            //  logfile.WriteLine("reappraise>>>");
            foreach (KeyValuePair <int, IUnitDef> scoutkvp in ScoutUnitDefsById)
            {
                int    scoutdeployedid = scoutkvp.Key;
                Float3 scoutpos        = aicallback.GetUnitPos(scoutdeployedid);

                Float3 nearestpos          = null;
                double bestsquareddistance = 100000000;
                int    targetid            = 0;
                // need to add index by position for this, to speed things up
                foreach (KeyValuePair <int, IUnitDef> enemykvp in EnemyController.GetInstance().EnemyUnitDefByDeployedId)
                {
                    int      deployedid = enemykvp.Key;
                    IUnitDef unitdef    = enemykvp.Value;
                    if (unitdef != null)
                    {
                        if (IsPriorityTarget(unitdef))
                        {
                            logfile.WriteLine("considering unit " + deployedid + " " + unitdef.name);
                            Float3 thispos             = aicallback.GetUnitPos(deployedid);
                            double thissquareddistance = Float3Helper.GetSquaredDistance(scoutpos, thispos);
                            if (thissquareddistance < bestsquareddistance)
                            {
                                bool nolasertowersnear = true;
                                foreach (KeyValuePair <int, IUnitDef> attackerkvp in EnemyController.GetInstance().EnemyUnitDefByDeployedId)
                                {
                                    int      attackerid      = attackerkvp.Key;
                                    IUnitDef attackerunitdef = attackerkvp.Value;
                                    if (attackerunitdef != null)
                                    {
                                        if (IsLaserTower(attackerunitdef))
                                        {
                                            Float3 attackerpos = aicallback.GetUnitPos(attackerid);
                                            if (Float3Helper.GetSquaredDistance(attackerpos, thispos) < nearbyforenemiesmeans * nearbyforenemiesmeans)
                                            {
                                                nolasertowersnear = false;
                                            }
                                        }
                                    }
                                }
                                if (nolasertowersnear)
                                {
                                    nearestpos          = thispos;
                                    bestsquareddistance = thissquareddistance;
                                    targetid            = deployedid;
                                }
                            }
                        }
                    }
                }
                if (nearestpos != null)
                {
                    GiveOrderWrapper.GetInstance().Attack(scoutdeployedid, targetid);
                    if (!attackingscouts.Contains(scoutdeployedid))
                    {
                        attackingscouts.Add(scoutdeployedid);
                    }
                }
                else
                {
                    if (attackingscouts.Contains(scoutdeployedid))
                    {
                        ExploreWith(scoutdeployedid);
                        attackingscouts.Remove(scoutdeployedid);
                    }
                }
            }
            //     logfile.WriteLine("reappraise<<<");
        }
Exemple #24
0
 public void EnemyDamaged(int damaged, int attacker, float damage, Float3 dir) //called when an enemy inside los or radar is damaged
 {
 }
 //called when one of your units are damaged
 public void UnitDamaged(int damaged,int attacker,float damage, Float3 dir)
 {
     try
     {
         if( UnitDamagedEvent != null )
         {
             UnitDamagedEvent( damaged, attacker, damage, dir );
         }
     }
     catch( Exception e )
     {
         logfile.WriteLine( "Exception: " + e.ToString() );
         SendTextMsg("Exception: " + e.ToString());
     }
 }
Exemple #26
0
        public IUnitDef WhatShouldIBuild(UnitDefArrayList constructordef, int constructorid, Float3 pos)
        {
            Priorities.Add( 1.0, tanks, 5 )
            Priorities.Add( 0.8, radar, position )


            if (isfactory)
            {
                if (numbertanks < 5 || numberscouts >= 2 )
                {
                    if (haveenergy(buildtank))
                    {
                        if (havemetal(buildtank))
                        {
                            buildtank();
                        }
                    }
                    else
                    {
                        buildenergy();
                    }
                }
                else
                {
                    if (numberscouts < 1)
                    {
                        if( 
                    }
                }
            }

            if( isconstructor )
            {
            }
        }
 Float3 GetRandomDestination()
 {
     Float3 destination = new Float3();
     destination.x = random.Next(0, aicallback.GetMapWidth() * MovementMaps.SQUARE_SIZE );
     destination.z = random.Next( 0, aicallback.GetMapHeight() * MovementMaps.SQUARE_SIZE );
     destination.y = aicallback.GetElevation( destination.x, destination.y );
     return destination;
 }
Exemple #28
0
        void Build(int constructorid, IUnitDef unitdef)
        {
            Float3 constructorpos = aicallback.GetUnitPos(constructorid);

            BuildAt(constructorid, unitdef, constructorpos);
        }
 void Regroup( Float3 regouppos )
 {
     //   logfile.WriteLine( "AttackPackCoordinator regrouping to " + regouppos.ToString() );
       //  if( debugon )
     //    {
     //        aicallback.SendTextMsg( "AttackPackCoordinator regrouping to " + regouppos.ToString(), 0 );
      //   }
     MoveTo( regouppos );
 }
Exemple #30
0
 public static void WriteXmlElementToFloat3( XmlElement element, Float3 float3 )
 {
     float3.x = Convert.ToDouble( element.GetAttribute( "x" ) );
     float3.y = Convert.ToDouble( element.GetAttribute( "y" ) );
     float3.z = Convert.ToDouble( element.GetAttribute( "z" ) );
 }
Exemple #31
0
 public Float3(Float3 src)
 {
     this.x = src.x;
     this.y = src.y;
     this.z = src.z;
 }
 public void Reclaim(int unitid, Float3 pos, double radius)
 {
     GiveOrder(new ReclaimCommand(unitid, pos, radius));
 }
Exemple #33
0
 public UnitInCreation(IUnitRequester requester, IUnitDef unitdef, Float3 pos)
 {
     this.unitrequester = requester;
     this.unitdef       = unitdef;
     this.pos           = pos;
 }
 public void BuildUnit(int builderid, string targetunitname, Float3 pos)
 {
     int targetunittypeid = BuildTable.GetInstance().UnitDefByName[targetunitname.ToLower()].id;
     GiveOrder( new BuildCommand( builderid, targetunittypeid, pos ) );
 }
Exemple #35
0
 public static void WriteFloat3ToXmlElement( Float3 float3, XmlElement element )
 {
     element.SetAttribute( "x", float3.x.ToString() );
     element.SetAttribute( "y", float3.y.ToString() );
     element.SetAttribute( "z", float3.z.ToString() );
 }
Exemple #36
0
 public void UnitDamaged(int damaged, int attacker, float damage, Float3 dir)                                     //called when one of your units are damaged
 {
 }
 public void MoveTo(int unitid, Float3 pos)
 {
     GiveOrder( new MoveToCommand( unitid, pos ) );
 }
Exemple #38
0
 public void InitStartPos(Float3 startpos)
 {
     startarea = MovementMaps.GetInstance().GetArea(typicalunitdef, startpos);
 }
 public void Attack(int unitid, Float3 pos)
 {
     GiveOrder( new AttackCommand( unitid, new PositionTarget( pos ) ) );
 }
Exemple #40
0
        // just get nearest known slow enemy
        // otherwise any enemy
        // no priority for buildings
        public Float3 ChooseAttackPoint(Float3 ourpos)
        {
            int      bestid              = 0;
            bool     gotknownunit        = false;
            IUnitDef defforbestid        = null;
            Float3   posforbestid        = null;
            double   BestSquaredDistance = 100000000000;

            foreach (KeyValuePair <int, IUnitDef> kvp in enemycontroller.EnemyUnitDefByDeployedId)
            {
                int      thisenemyid = kvp.Key;
                IUnitDef unitdef     = kvp.Value;
                Float3   enemypos    = aicallback.GetUnitPos(thisenemyid);
                //Float3 enemypos = EnemyMap.GetInstance().
                // logfile.WriteLine( "Found building " +
                if (enemypos != null)
                {
                    if (MovementMaps.GetInstance().GetArea(typicalunitdef, enemypos) == startarea)
                    {
                        if (Float3Helper.GetSquaredDistance(new Float3(0, 0, 0), enemypos) > 1)
                        {
                            double thissquareddistance = Float3Helper.GetSquaredDistance(ourpos, enemypos);
                            if (unitdef != null)
                            {
                                if (unitdef.speed < maxenemyspeed) // if we already have building we dont care
                                {
                                    if (thissquareddistance < BestSquaredDistance)
                                    {
                                        //    logfile.WriteLine( "best known so far" );
                                        bestid              = thisenemyid;
                                        gotknownunit        = true;
                                        posforbestid        = enemypos;
                                        defforbestid        = unitdef;
                                        BestSquaredDistance = thissquareddistance;
                                    }
                                }
                            }
                            else
                            {
                                if (!gotknownunit) // otherwise just ignore unknown units
                                {
                                    if (thissquareddistance < BestSquaredDistance)
                                    {
                                        //    logfile.WriteLine( "best unknown so far" );
                                        bestid              = thisenemyid;
                                        posforbestid        = enemypos;
                                        defforbestid        = unitdef;
                                        BestSquaredDistance = thissquareddistance;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            foreach (KeyValuePair <int, Float3> kvp in enemycontroller.EnemyStaticPosByDeployedId)
            {
                //  logfile.WriteLine( "EnemySelector: checking static... " );
                int    thisenemyid = kvp.Key;
                Float3 enemypos    = kvp.Value;
                if (enemypos != null)
                {
                    double thissquareddistance = Float3Helper.GetSquaredDistance(ourpos, enemypos);
                    //  logfile.WriteLine( "EnemySelector: Potential enemy at " + enemypos.ToString() + " squareddistance: " + thissquareddistance );
                    if (thissquareddistance < BestSquaredDistance)
                    {
                        //   logfile.WriteLine( "EnemySelector: best distance so far" );
                        bestid = thisenemyid;
                        //gotbuilding = true;
                        gotknownunit = true;
                        posforbestid = enemypos;
                        //defforbestid = unitdef;
                    }
                }
            }
            return(posforbestid);
        }
 public UnitInCreation(IUnitRequester requester, IUnitDef unitdef, Float3 pos)
 {
     this.unitrequester = requester;
     this.unitdef = unitdef;
     this.pos = pos;
 }
Exemple #42
0
        // this is going to have to interact with all sorts of stuff in the future
        // for now keep it simple
        // for now we look for nearby buildings, then nearby enemy units with low speed, then anything
        public Float3 ChooseAttackPoint(Float3 ourpos)
        {
            bool   gotbuilding         = false;
            bool   gotknownunit        = false;
            double BestSquaredDistance = 100000000000;

            int      bestid       = 0;
            IUnitDef defforbestid = null;
            Float3   posforbestid = null;

            //   logfile.WriteLine( "EnemySelector: checking mobile... " );
            foreach (DictionaryEntry de in enemycontroller.EnemyUnitDefByDeployedId)
            {
                int      thisenemyid = (int)de.Key;
                IUnitDef unitdef     = de.Value as IUnitDef;
                Float3   enemypos    = aicallback.GetUnitPos(thisenemyid);
                // logfile.WriteLine( "Found building " +
                double thissquareddistance = Float3Helper.GetSquaredDistance(ourpos, enemypos);
                //   logfile.WriteLine( "EnemySelector: Potential enemy at " + enemypos.ToString() + " squareddistance: " + thissquareddistance );
                if (unitdef != null)
                {
                    //   logfile.WriteLine( "unitdef not null " + unitdef.humanName + " ismobile: " + unitdefhelp.IsMobile( unitdef ).ToString() );
                    //   logfile.WriteLine( "gotbuilding = " + gotbuilding.ToString() );
                    if (gotbuilding)
                    {
                        if (!unitdefhelp.IsMobile(unitdef))
                        {
                            if (thissquareddistance < BestSquaredDistance)
                            {
                                //  logfile.WriteLine( "best building so far" );
                                bestid              = thisenemyid;
                                gotbuilding         = true;
                                gotknownunit        = true;
                                posforbestid        = enemypos;
                                defforbestid        = unitdef;
                                BestSquaredDistance = thissquareddistance;
                            }
                        }
                    }
                    else
                    {
                        if (unitdef.speed < maxenemyspeed)  // if we already have building we dont care
                        {
                            if (thissquareddistance < BestSquaredDistance)
                            {
                                //    logfile.WriteLine( "best known so far" );
                                bestid              = thisenemyid;
                                gotknownunit        = true;
                                posforbestid        = enemypos;
                                defforbestid        = unitdef;
                                BestSquaredDistance = thissquareddistance;
                            }
                        }
                    }
                }
                else // if unitdef unknown
                {
                    //  logfile.WriteLine( "gotknownunit = " + gotknownunit.ToString() );
                    if (!gotknownunit)  // otherwise just ignore unknown units
                    {
                        if (thissquareddistance < BestSquaredDistance)
                        {
                            //    logfile.WriteLine( "best unknown so far" );
                            bestid              = thisenemyid;
                            posforbestid        = enemypos;
                            defforbestid        = unitdef;
                            BestSquaredDistance = thissquareddistance;
                        }
                    }
                }
            }

            foreach (DictionaryEntry de in enemycontroller.EnemyStaticPosByDeployedId)
            {
                //  logfile.WriteLine( "EnemySelector: checking static... " );
                int    thisenemyid         = (int)de.Key;
                Float3 enemypos            = de.Value as Float3;
                double thissquareddistance = Float3Helper.GetSquaredDistance(ourpos, enemypos);
                //  logfile.WriteLine( "EnemySelector: Potential enemy at " + enemypos.ToString() + " squareddistance: " + thissquareddistance );
                if (thissquareddistance < BestSquaredDistance)
                {
                    //   logfile.WriteLine( "EnemySelector: best distance so far" );
                    bestid       = thisenemyid;
                    gotbuilding  = true;
                    gotknownunit = true;
                    posforbestid = enemypos;
                    //defforbestid = unitdef;
                }
            }

            //if( enemycontroller.EnemyStaticPosByDeployedId.Contains( bestid ) )
            // {
            //     enemycontroller.EnemyStaticPosByDeployedId.Remove( bestid );
            // }

            return(posforbestid);
        }
Exemple #43
0
        void csai_UnitIdleEvent(int deployedunitid)
        {
            IUnitDef unitdef = UnitController.GetInstance().UnitDefByDeployedId[deployedunitid];

            if (!unitdef.canBuild)
            {
                //logfile.WriteLine("cantbuild");
                return;
            }
            logfile.WriteLine("unitidleevent " + deployedunitid + " " + unitdef.name + " " + unitdef.humanName);
            if (ActiveConstructors.Contains(deployedunitid))
            {
                ActiveConstructors.Remove(deployedunitid);
            }
            Ownership.GetInstance().SignalConstructorIsIdle(deployedunitid);
            double       highestpriority = 0;
            List <Order> bestorders      = new List <Order>();

            foreach (Order order in orders)
            {
                double thispriority = order.priority;
                if (thispriority >= highestpriority)
                {
                    int currentunits = order.unitsunderconstruction.Count;
                    if (UnitController.GetInstance().UnitDefsByName.ContainsKey(order.unitname))
                    {
                        currentunits += UnitController.GetInstance().UnitDefsByName[order.unitname].Count;
                    }
                    if (currentunits < order.quantity)
                    {
                        if (BuildTree.GetInstance().CanBuild(unitdef.name.ToLower(), order.unitname))
                        {
                            //if( CanBuild(deployedunitid,
                            if (thispriority > highestpriority)
                            {
                                highestpriority = thispriority;
                                bestorders      = new List <Order>();
                                bestorders.Add(order);
                                csai.DebugSay("Possible order: " + order.ToString());
                            }
                            else if (thispriority == highestpriority)
                            {
                                bestorders.Add(order);
                                csai.DebugSay("Possible order: " + order.ToString());
                            }
                        }
                    }
                }
            }
            //if (bestorders.Count == 0)
            //  {
            //      csai.DebugSay("No orders found");
            //      return;
            //  }
            List <Order> possibleorders = new List <Order>(); // get orders this unit can build
            bool         metalneeded    = false;
            bool         energyneeded   = false;
            IUnitDef     deftobuild     = null;

            foreach (Order order in bestorders)
            {
                csai.DebugSay("bestorder " + order.unitname);
                //if( BuildTree.GetInstance().CanBuild( unitdef.name.ToLower(), order.unitname ) )
                //{
                deftobuild = BuildTable.GetInstance().UnitDefByName[order.unitname];
                if (MetalController.GetInstance().CanBuild(deftobuild))
                {
                    if (EnergyController.GetInstance().CanBuild(deftobuild))
                    {
                        possibleorders.Add(order);
                        csai.DebugSay("possible: " + order.unitname);
                    }
                    else
                    {
                        csai.DebugSay("needs energy");
                        energyneeded = true;
                    }
                }
                else
                {
                    csai.DebugSay("needs metal");
                    metalneeded = true;
                }
                //}
            }
            if (possibleorders.Count == 0)
            {
                if (Level1ConstructorList.GetInstance().defbyid.Count < 1 &&
                    !UnitController.GetInstance().UnitDefsByName.ContainsKey("armcom"))
                {
                    if (BuildConstructionVehicle(deployedunitid, unitdef))
                    {
                        return;
                    }
                }

                if (energyneeded || aicallback.GetEnergy() < aicallback.GetEnergyStorage() / 5)
                {
                    if (BuildSolarCell(deployedunitid))
                    {
                        logfile.WriteLine("building solarcell");
                        if (AssistingConstructors.ContainsKey(deployedunitid))
                        {
                            AssistingConstructors.Remove(deployedunitid);
                        }
                        return;
                    }
                }
                if (metalneeded || aicallback.GetMetal() < aicallback.GetMetalStorage() / 5)
                {
                    Float3 reclaimpos = ReclaimHelper.GetNearestReclaim(aicallback.GetUnitPos(deployedunitid), deployedunitid);
                    if (reclaimpos != null)
                    {
                        GiveOrderWrapper.GetInstance().Reclaim(deployedunitid, reclaimpos, 100);
                        return;
                    }
                    if (BuildMex(deployedunitid))
                    {
                        logfile.WriteLine("building mex");
                        if (AssistingConstructors.ContainsKey(deployedunitid))
                        {
                            AssistingConstructors.Remove(deployedunitid);
                        }
                        return;
                    }
                }


                logfile.WriteLine("offering assistance");
                OfferAssistance(deployedunitid);
                return;
            }
            Order ordertodo = possibleorders[random.Next(0, possibleorders.Count)];

            if (ordertodo.unitname == "armmex")
            {
                BuildMex(deployedunitid);
                if (AssistingConstructors.ContainsKey(deployedunitid))
                {
                    AssistingConstructors.Remove(deployedunitid);
                }
            }
            else
            {
                //ordertodo.unitsunderconstruction += 1;
                deftobuild = BuildTable.GetInstance().UnitDefByName[ordertodo.unitname];
                Float3           pos            = BuildUnit(deployedunitid, ordertodo.unitname);
                Ownership.IOrder ownershiporder = Ownership.GetInstance().RegisterBuildingOrder(this,
                                                                                                deployedunitid,
                                                                                                deftobuild, pos);
                logfile.WriteLine("building: " + ordertodo.unitname);
                ordertodo.unitsunderconstruction.Add(ownershiporder);
                if (AssistingConstructors.ContainsKey(deployedunitid))
                {
                    AssistingConstructors.Remove(deployedunitid);
                }
            }
        }
Exemple #44
0
        bool activated = false; // not started until Activate or SetTarget is called

        // does NOT imply Activate()
        public void SetTarget(Float3 newtarget)
        {
            this.targetpos = newtarget;
            //Activate();
        }
        // this is going to have to interact with all sorts of stuff in the future
        // for now keep it simple
        // for now we look for nearby buildings, then nearby enemy units with low speed, then anything
        public Float3 ChooseAttackPoint( Float3 ourpos )
        {
            bool gotbuilding = false;
            bool gotknownunit = false;
            double BestSquaredDistance = 100000000000;

            int bestid = 0;
            IUnitDef defforbestid = null;
            Float3 posforbestid = null;
             //   logfile.WriteLine( "EnemySelector: checking mobile... " );
            foreach( DictionaryEntry de in enemycontroller.EnemyUnitDefByDeployedId )
            {
                int thisenemyid = (int)de.Key;
                IUnitDef unitdef = de.Value as IUnitDef;
                Float3 enemypos = aicallback.GetUnitPos( thisenemyid );
               // logfile.WriteLine( "Found building " +
                double thissquareddistance = Float3Helper.GetSquaredDistance( ourpos, enemypos );
             //   logfile.WriteLine( "EnemySelector: Potential enemy at " + enemypos.ToString() + " squareddistance: " + thissquareddistance );
                if( unitdef != null )
                {
                 //   logfile.WriteLine( "unitdef not null " + unitdef.humanName + " ismobile: " + unitdefhelp.IsMobile( unitdef ).ToString() );
                 //   logfile.WriteLine( "gotbuilding = " + gotbuilding.ToString() );
                    if( gotbuilding )
                    {
                        if( !unitdefhelp.IsMobile( unitdef ) )
                        {
                            if( thissquareddistance < BestSquaredDistance )
                            {
                              //  logfile.WriteLine( "best building so far" );
                                bestid = thisenemyid;
                                gotbuilding = true;
                                gotknownunit = true;
                                posforbestid = enemypos;
                                defforbestid = unitdef;
                                BestSquaredDistance = thissquareddistance;
                            }
                        }
                    }
                    else
                    {
                        if( unitdef.speed < maxenemyspeed ) // if we already have building we dont care
                        {
                            if( thissquareddistance < BestSquaredDistance )
                            {
                            //    logfile.WriteLine( "best known so far" );
                                bestid = thisenemyid;
                                gotknownunit = true;
                                posforbestid = enemypos;
                                defforbestid = unitdef;
                                BestSquaredDistance = thissquareddistance;
                            }
                        }
                    }
                }
                else // if unitdef unknown
                {
                  //  logfile.WriteLine( "gotknownunit = " + gotknownunit.ToString() );
                    if( !gotknownunit ) // otherwise just ignore unknown units
                    {
                        if( thissquareddistance < BestSquaredDistance )
                        {
                        //    logfile.WriteLine( "best unknown so far" );
                            bestid = thisenemyid;
                            posforbestid = enemypos;
                            defforbestid = unitdef;
                            BestSquaredDistance = thissquareddistance;
                        }
                    }
                }
            }

            foreach( DictionaryEntry de in enemycontroller.EnemyStaticPosByDeployedId )
            {
              //  logfile.WriteLine( "EnemySelector: checking static... " );
                int thisenemyid = (int)de.Key;
                Float3 enemypos = de.Value as Float3;
                double thissquareddistance = Float3Helper.GetSquaredDistance( ourpos, enemypos );
              //  logfile.WriteLine( "EnemySelector: Potential enemy at " + enemypos.ToString() + " squareddistance: " + thissquareddistance );
                if( thissquareddistance < BestSquaredDistance )
                {
                 //   logfile.WriteLine( "EnemySelector: best distance so far" );
                    bestid = thisenemyid;
                    gotbuilding = true;
                    gotknownunit = true;
                    posforbestid = enemypos;
                    //defforbestid = unitdef;
                }
            }

            //if( enemycontroller.EnemyStaticPosByDeployedId.Contains( bestid ) )
               // {
               //     enemycontroller.EnemyStaticPosByDeployedId.Remove( bestid );
               // }

            return posforbestid;
        }
 public BuildCommand(int builder, int idtobuild, Float3 pos)
 {
     this.UnitToReceiveOrder = builder;
     this.idtobuild          = idtobuild;
     this.pos = pos;
 }
Exemple #47
0
        void ExploreWith(int unitid)
        {
            Float3 destination = GetRandomDestination();

            aicallback.GiveOrder(unitid, new Command(Command.CMD_MOVE, destination.ToDoubleArray()));
        }
Exemple #48
0
 public Radar(Float3 pos, double radius, IUnitDef unitdef)
 {
     this.Pos     = pos;
     this.radius  = radius;
     this.unitdef = unitdef;
 }
 //called when an enemy inside los or radar is damaged
 public void EnemyDamaged(int damaged,int attacker,float damage, Float3 dir)
 {
 }
Exemple #50
0
 public AdvancedFloat3(Float3 float3) : base(float3)
 {
 }
Exemple #51
0
 public static double GetSquaredDistance(Float3 one, Float3 two)
 {
     return((two.x - one.x) * (two.x - one.x) + (two.y - one.y) * (two.y - one.y) + (two.z - one.z) * (two.z - one.z));
 }
Exemple #52
0
 public Float3 GetNearestMetalSpot( Float3 mypos )
 {
     if( !isMetalMap )
     {
         double closestdistancesquared = 1000000000000;
         Float3 bestpos = null;
         MetalSpot bestspot = null;
         foreach( MetalSpot metalspot in MetalSpots )
         {
             if( !MetalSpotsUsed.Contains( metalspot ) )
             {
                 if( bestpos == null )
                 {
                     bestpos = metalspot.Pos;
                 }
                 double thisdistancesquared = Float3Helper.GetSquaredDistance( mypos, metalspot.Pos );
                 //logfile.WriteLine( "thisdistancesquared = " + thisdistancesquared + " closestdistancesquared= " + closestdistancesquared );
                 if( thisdistancesquared < closestdistancesquared )
                 {
                     closestdistancesquared = thisdistancesquared;
                     bestpos = metalspot.Pos;
                     bestspot = metalspot;
                 }
             }
         }
         return bestspot.Pos;
     }
     else
     {
         return mypos; // if metal map just return passed-in pos
     }
 }
Exemple #53
0
 public static void WriteXmlElementToFloat3(XmlElement element, Float3 float3)
 {
     float3.x = Convert.ToDouble(element.GetAttribute("x"));
     float3.y = Convert.ToDouble(element.GetAttribute("y"));
     float3.z = Convert.ToDouble(element.GetAttribute("z"));
 }
Exemple #54
0
 public MetalSpot( int amount, Float3 pos )
 {
     Amount = amount;
     Pos = pos;
 }
 // does NOT imply Activate()
 public void SetTarget( Float3 newtarget )
 {
     this.targetpos = newtarget;
     //Activate();
 }
Exemple #56
0
 public MetalSpot( int amount, Float3 pos, bool isoccupied )
 {
     Amount = amount;
     IsOccupied = isoccupied;
     Pos = pos;
 }
 void MoveTo( Float3 pos )
 {
     // check whether we really need to do anything or if order is roughly same as last one
     aicallback.DrawUnit("ARMSOLAR", pos, 0.0f, 50, aicallback.GetMyAllyTeam(), true, true);
     if( restartedfrompause || Float3Helper.GetSquaredDistance( pos, lasttargetpos ) > ( movetothreshold * movetothreshold ) )
     {
         aicallback.GiveGroupOrder( groupid, new Command( Command.CMD_MOVE, pos.ToDoubleArray() ) );
         /*
         foreach( DictionaryEntry de in UnitDefListByDeployedId )
         {
             int deployedid = (int)de.Key;
             IUnitDef unitdef = de.Value as IUnitDef;
             aicallback.GiveOrder( deployedid, new Command( Command.CMD_MOVE, pos.ToDoubleArray() ) );
         }
         */
         restartedfrompause = false;
         lasttargetpos = pos;
     }
 }
Exemple #58
0
 // loads cache file
 // returns true if cache loaded ok, otherwise false if not found, out-of-date, etc
 // we check the version and return false if out-of-date
 bool LoadCache()
 {
     string MapName = aicallback.GetMapName();
     string cachefilepath = Path.Combine( csai.CacheDirectoryPath, MapName + "_metal.xml" );
     
     if( !File.Exists( cachefilepath ) )
     {
         logfile.WriteLine( "cache file doesnt exist -> building" );
         return false;
     }
     
     XmlDocument cachedom = XmlHelper.OpenDom( cachefilepath );
     XmlElement metadata = cachedom.SelectSingleNode( "/root/metadata" ) as XmlElement;
     string cachemetalclassversion = metadata.GetAttribute( "version" );
     if( cachemetalclassversion != MetalClassVersion )
     {
         logfile.WriteLine( "cache file out of date ( " + cachemetalclassversion + " vs " + MetalClassVersion + " ) -> rebuilding" );
         return false;
     }
     
     logfile.WriteLine( cachedom.InnerXml );
     
     isMetalMap = Convert.ToBoolean( metadata.GetAttribute( "ismetalmap" ) );
     
     if( isMetalMap )
     {
         logfile.WriteLine( "metal map" );
         return true;
     }
     
     
     XmlElement metalspots = cachedom.SelectSingleNode( "/root/metalspots" ) as XmlElement;
     ArrayList metalspotsal = new ArrayList();
     foreach( XmlElement metalspot in metalspots.SelectNodes( "metalspot" ) )
     {
         int amount = Convert.ToInt32( metalspot.GetAttribute("amount") );
         Float3 pos = new Float3();
         Float3Helper.WriteXmlElementToFloat3( metalspot, pos );
         //pos.LoadCsv( metalspot.GetAttribute("pos") );
         MetalSpot newmetalspot = new MetalSpot( amount, pos );
         metalspotsal.Add( newmetalspot );
         // logfile.WriteLine( "metalspot xml: " + metalspot.InnerXml );
         logfile.WriteLine( "metalspot: " + newmetalspot.ToString() );
     }
     MetalSpots = (MetalSpot[])metalspotsal.ToArray( typeof( MetalSpot ) );
     
     logfile.WriteLine( "cache file loaded" );
     return true;
 }
 public UnitInfo( int deployedid, Float3 pos, IUnitDef unitdef, double squareddistance )
 {
     this.deployedid = deployedid;
     this.pos = pos;
     this.unitdef = unitdef;
     this.squareddistance = squareddistance;
 }
Exemple #60
0
        // algorithm more or less by krogothe
        // ported from Submarine's original C++ version
        public void SearchMetalSpots()
        {	
            logfile.WriteLine( "SearchMetalSpots() >>>");
            
            isMetalMap = false;
        
            ArrayList metalspotsal = new ArrayList();
            
            int mapheight = aicallback.GetMapHeight() / 2; //metal map has 1/2 resolution of normal map
            int mapwidth = aicallback.GetMapWidth() / 2;
            double mapmaxmetal = aicallback.GetMaxMetal();
            int totalcells = mapheight * mapwidth;
            
            logfile.WriteLine( "mapwidth: " + mapwidth + " mapheight " + mapheight + " maxmetal:" + mapmaxmetal );
            
            byte[] metalmap = aicallback.GetMetalMap(); // original metal map
            int[,] metalremaining = new int[ mapwidth, mapheight ];  // actual metal available at that point. we remove metal from this as we add spots to MetalSpots
            int[,] SpotAvailableMetal = new int [ mapwidth, mapheight ]; // amount of metal an extractor on this spot could make
            int[,] NormalizedSpotAvailableMetal = new int [ mapwidth, mapheight ]; // SpotAvailableMetal, normalized to 0-255 range
        
            int totalmetal = 0;
            ArrayIndexer arrayindexer = new ArrayIndexer( mapwidth, mapheight );
            //Load up the metal Values in each pixel
            logfile.WriteLine( "width: " + mapwidth + " height: " + mapheight );
            for (int y = 0; y < mapheight; y++)
            {
                //string logline = "";
                for( int x = 0; x < mapwidth; x++ )
                {
                    metalremaining[ x, y ] = (int)metalmap[ arrayindexer.GetIndex( x, y ) ];
                    totalmetal += metalremaining[ x, y ];		// Count the total metal so you can work out an average of the whole map
                    //logline += metalremaining[ x, y ].ToString() + " ";
                  //  logline += metalremaining[ x, y ] + " ";
                }
               // logfile.WriteLine( logline );
            }
            logfile.WriteLine ("*******************************************");
        
            double averagemetal = ((double)totalmetal) / ((double)totalcells);  //do the average
           // int maxmetal = 0;

            int ExtractorRadius = (int)( aicallback.GetExtractorRadius() / 16.0 );
            int DoubleExtractorRadius = ExtractorRadius * 2;
            int SquareExtractorRadius = ExtractorRadius * ExtractorRadius; //used to speed up loops so no recalculation needed
            int FourSquareExtractorRadius = 4 * SquareExtractorRadius; // same as above 
            double CellsInRadius = Math.PI * ExtractorRadius * ExtractorRadius;
            
            int maxmetalspotamount = 0;
            logfile.WriteLine( "Calculating available metal for each spot..." );
            SpotAvailableMetal = CalculateAvailableMetalForEachSpot( metalremaining, ExtractorRadius, out maxmetalspotamount );
            
            logfile.WriteLine( "Normalizing..." );
            // normalize the metal so any map will have values 0-255, no matter how much metal it has
            int[,] NormalizedMetalRemaining = new int[ mapwidth, mapheight ];
            for (int y = 0; y < mapheight; y++)
            {
                for (int x = 0; x < mapwidth; x++)
                {
                    NormalizedSpotAvailableMetal[ x, y ] = ( SpotAvailableMetal[ x, y ] * 255 ) / maxmetalspotamount;
                }
            }
            
            logfile.WriteLine( "maxmetalspotamount: " + maxmetalspotamount );
            
            bool Stopme = false;
            int SpotsFound = 0;
            //logfile.WriteLine( BuildTable.GetInstance().GetBiggestMexUnit().ToString() );
           // IUnitDef biggestmex = BuildTable.GetInstance().GetBiggestMexUnit();
           // logfile.WriteLine( "biggestmex is " + biggestmex.name + " " + biggestmex.humanName );
            for (int spotindex = 0; spotindex < MaxSpots && !Stopme; spotindex++)
            {	                
                logfile.WriteLine( "spotindex: " + spotindex );
                int bestspotx = 0, bestspoty = 0;
                int actualmetalatbestspot = 0; // use to try to put extractors over spot itself
                //finds the best spot on the map and gets its coords
                int BestNormalizedAvailableSpotAmount = 0;
                for (int y = 0; y < mapheight; y++)
                {
                    for (int x = 0; x < mapwidth; x++)
                    {
                        if( NormalizedSpotAvailableMetal[ x, y ] > BestNormalizedAvailableSpotAmount ||
                            ( NormalizedSpotAvailableMetal[ x, y ] == BestNormalizedAvailableSpotAmount && 
                            metalremaining[ x, y ] > actualmetalatbestspot ) )
                        {
                            BestNormalizedAvailableSpotAmount = NormalizedSpotAvailableMetal[ x, y ];
                            bestspotx = x;
                            bestspoty = y;
                            actualmetalatbestspot = metalremaining[ x, y ];
                        }
                    }
                }		
                logfile.WriteLine( "BestNormalizedAvailableSpotAmount: " + BestNormalizedAvailableSpotAmount );                
                if( BestNormalizedAvailableSpotAmount < MinMetalForSpot )
                {
                    Stopme = true; // if the spots get too crappy it will stop running the loops to speed it all up
                    logfile.WriteLine( "Remaining spots too small; stopping search" );
                }
        
                if( !Stopme )
                {
                    Float3 pos = new Float3();
                    pos.x = bestspotx * 2 * MovementMaps.SQUARE_SIZE;
                    pos.z = bestspoty * 2 * MovementMaps.SQUARE_SIZE;
                    pos.y = aicallback.GetElevation( pos.x, pos.z );
                    
                    //pos = Map.PosToFinalBuildPos( pos, biggestmex );
                
                    logfile.WriteLine( "Metal spot: " + pos + " " + BestNormalizedAvailableSpotAmount );
                    MetalSpot thismetalspot = new MetalSpot( (int)( ( BestNormalizedAvailableSpotAmount  * mapmaxmetal * maxmetalspotamount ) / 255 ), pos );
                    
                //    if (aicallback.CanBuildAt(biggestmex, pos) )
                  //  {
                       // pos = Map.PosToBuildMapPos( pos, biggestmex );
                       // logfile.WriteLine( "Metal spot: " + pos + " " + BestNormalizedAvailableSpotAmount );
                        
                   //     if(pos.z >= 2 && pos.x >= 2 && pos.x < mapwidth -2 && pos.z < mapheight -2)
                  //      {
                          //  if(CanBuildAt(pos.x, pos.z, biggestmex.xsize, biggestmex.ysize))
                           // {
                                metalspotsal.Add( thismetalspot );			
                                SpotsFound++;
        
                                //if(pos.y >= 0)
                                //{
                                   // SetBuildMap(pos.x-2, pos.z-2, biggestmex.xsize+4, biggestmex.ysize+4, 1);
                                //}
                                //else
                                //{
                                    //SetBuildMap(pos.x-2, pos.z-2, biggestmex.xsize+4, biggestmex.ysize+4, 5);
                                //}
                          //  }
                     //   }
                 //   }
                        
                    for (int myx = bestspotx - (int)ExtractorRadius; myx < bestspotx + (int)ExtractorRadius; myx++)
                    {
                        if (myx >= 0 && myx < mapwidth )
                        {
                            for (int myy = bestspoty - (int)ExtractorRadius; myy < bestspoty + (int)ExtractorRadius; myy++)
                            {
                                if ( myy >= 0 && myy < mapheight &&
                                    ( ( bestspotx - myx ) * ( bestspotx - myx ) + ( bestspoty - myy ) * ( bestspoty - myy ) ) <= (int)SquareExtractorRadius )
                                {
                                    metalremaining[ myx, myy ] = 0; //wipes the metal around the spot so its not counted twice
                                    NormalizedSpotAvailableMetal[ myx, myy ] = 0;
                                }
                            }
                        }
                    }
        
                    // Redo the whole averaging process around the picked spot so other spots can be found around it
                    for (int y = bestspoty - (int)DoubleExtractorRadius; y < bestspoty + (int)DoubleExtractorRadius; y++)
                    {
                        if(y >=0 && y < mapheight)
                        {
                            for (int x = bestspotx - (int)DoubleExtractorRadius; x < bestspotx + (int)DoubleExtractorRadius; x++)
                            {
                                //funcion below is optimized so it will only update spots between r and 2r, greatly speeding it up
                                if((bestspotx - x)*(bestspotx - x) + (bestspoty - y)*(bestspoty - y) <= (int)FourSquareExtractorRadius && 
                                    x >=0 && x < mapwidth && 
                                    NormalizedSpotAvailableMetal[ x, y ] > 0 )
                                {
                                    totalmetal = 0;
                                    for (int myx = x - (int)ExtractorRadius; myx < x + (int)ExtractorRadius; myx++)
                                    {
                                        if (myx >= 0 && myx < mapwidth )
                                        {
                                            for (int myy = y - (int)ExtractorRadius; myy < y + (int)ExtractorRadius; myy++)
                                            { 
                                                if (myy >= 0 && myy < mapheight && 
                                                    ((x - myx)*(x - myx) + (y - myy)*(y - myy)) <= (int)SquareExtractorRadius )
                                                {
                                                    totalmetal += metalremaining[ myx, myy ]; //recalculate nearby spots to account for deleted metal from chosen spot
                                                }
                                            }
                                        }
                                    }
                                    NormalizedSpotAvailableMetal[ x, y ] = totalmetal * 255 / maxmetalspotamount; //set that spots metal amount 
                                }
                            }
                        }
                    }
                }
            }
        
            if(SpotsFound > 500)
            {
                isMetalMap = true;
                metalspotsal.Clear();
                logfile.WriteLine( "Map is considered to be a metal map" );
            }
            else
            {
                isMetalMap = false;
        
                // debug
                //for(list<AAIMetalSpot>::iterator spot = metal_spots.begin(); spot != metal_spots.end(); spot++)
            }
            
            MetalSpots = ( MetalSpot[] )metalspotsal.ToArray( typeof( MetalSpot ) );
            
            SaveCache();
            logfile.WriteLine( "SearchMetalSpots() <<<");
        }