示例#1
0
        bool ShipComponentExperiment(monocle.Telegraph telegraph)
        {
            List <monocle.ShipData> ships = null;

            if (!telegraph.GetAllShips(monocle.Area.OldWorld, out ships))
            {
                return(false);
            }

            for (ulong i = 0; i < 2048; ++i)
            {
                ulong address = 0;

                if (!telegraph.GetShipComponentAddress(ships[0].shipId, i, out address))
                {
                    continue;
                }

                if (address == 0)
                {
                    continue;
                }

                string idString      = i.ToString();
                string addressString = address.ToString("X");

                Console.WriteLine(string.Format("{0} {1}", idString, addressString));
            }

            return(true);
        }
示例#2
0
        bool SendShipToPosition(monocle.Telegraph telegraph)
        {
            List <monocle.ShipData> shipsData = null;

            if (!telegraph.GetAllShips(monocle.Area.OldWorld, out shipsData))
            {
                return(false);
            }

            List <ulong> shipsID = (from d in shipsData select d.shipId).ToList();

            if (!telegraph.AddWaypoint(shipsID, new monocle.Coordinate()
            {
                x = 1111f, y = 1616
            }))
            {
                return(false);
            }

            return(true);
        }
示例#3
0
        void Demo()
        {
            monocle.Telegraph telegraph = new monocle.Telegraph();

            List <ShipData> testShips;

            telegraph.GetAllShips(Area.OldWorld, out testShips);

            return;

            List <monocle.IslandData> islandData = new List <monocle.IslandData>();

            if (!telegraph.GetIslandsByName("Shortisland", out islandData))
            {
                return;
            }

            monocle.IslandData island = islandData.First();

            List <monocle.BuildingData> buildings = new List <monocle.BuildingData>();

            if (!telegraph.GetIslandBuildings(islandData.First().id, out buildings))
            {
                return;
            }

            foreach (var building in buildings)
            {
                if (building.buidlingType == monocle.Building.SmallTradingPost)
                {
                    for (ulong i = 0; i < 2048; ++i)
                    {
                        ulong compAddress = 0;

                        telegraph.GetBuildingComponentAddress(islandData.First().id, building.id, i, out compAddress);

                        if (compAddress != 0)
                        {
                            string sAddress = compAddress.ToString("X");
                            string sI       = i.ToString();

                            Console.WriteLine(string.Format("{0} {1}", sI, sAddress));
                        }
                    }
                }


                monocle.ProductionNode productionNode;

                if (!telegraph.GetBuildingProduction(island.id, building.id, out productionNode))
                {
                    continue;
                }
            }

            List <monocle.ConsumptionNode> consumption = new List <monocle.ConsumptionNode>();

            if (!telegraph.GetIslandConsumption(island.id, out consumption))
            {
                return;
            }

            List <monocle.ShipData> ships = new List <monocle.ShipData>();

            if (!telegraph.GetAllShips(monocle.Area.OldWorld, out ships))
            {
                return;
            }

            ships = (from s in ships where s.shipType == monocle.ShipType.Clipper select s).ToList();

            monocle.ShipMoveData moveData;

            if (!telegraph.GetShipMoveData(ships.First().shipId, out moveData))
            {
                return;
            }

            monocle.Coordinate target = moveData.position;
            target.x = target.x + 100;

            List <ulong> ids = (from s in ships select s.shipId).ToList();

            if (!telegraph.AddWaypoint(ids, target))
            {
                return;
            }

            List <monocle.ShipCargoSlot> cargo = new List <monocle.ShipCargoSlot>();

            if (!telegraph.GetShipCargo(ids.First(), out cargo))
            {
                return;
            }

            if (!telegraph.ShipDumpCargo(ids.First(), 1))
            {
                return;
            }

            ulong address = 0;

            telegraph.GetShipComponentAddress(ids.First(), 253, out address);
        }
示例#4
0
        void Run(string[] args)
        {
            monocle.Telegraph telegraph = new monocle.Telegraph();

            List <monocle.IslandData> islands = new List <IslandData>();

            List <Delivery> deliveries = new List <Delivery>();

            Dictionary <ulong, monocle.Coordinate> tradingPosts = new Dictionary <ulong, monocle.Coordinate>();

            foreach (string name in args)
            {
                List <IslandData> tempData = null;
                if (!telegraph.GetIslandsByName(name, out tempData))
                {
                    Console.WriteLine("Could not get island");
                    return;
                }

                islands.AddRange(tempData);
            }

            while (true)
            {
                var islandResources = new Dictionary <monocle.IslandData, Dictionary <monocle.Resource, IslandResourceData> >();

                foreach (var island in islands)
                {
                    Dictionary <monocle.Resource, IslandResourceData> islandResource = new Dictionary <monocle.Resource, IslandResourceData>();

                    List <monocle.IslandResourceRecord> resources = new List <monocle.IslandResourceRecord>();

                    if (!telegraph.GetIslandResources(island.id, out resources))
                    {
                        return;
                    }

                    foreach (var record in resources)
                    {
                        islandResource.Add(record.resourceType, new IslandResourceData()
                        {
                            capacity = (int)record.capacity,
                            amount   = (int)record.amount,
                            rate     = 0.0,
                        });
                    }

                    List <monocle.ConsumptionNode> consumption = null;

                    if (!telegraph.GetIslandConsumption(island.id, out consumption))
                    {
                        return;
                    }

                    foreach (ConsumptionNode node in consumption)
                    {
                        IslandResourceData data = islandResource[node.resourceType];
                        data.rate -= node.rate;
                        islandResource[node.resourceType] = data;
                    }

                    List <monocle.BuildingData> buildings = null;

                    if (!telegraph.GetIslandBuildings(island.id, out buildings))
                    {
                        return;
                    }

                    foreach (var building in buildings)
                    {
                        if (building.buidlingType == monocle.Building.LargeTradingPost ||
                            building.buidlingType == monocle.Building.MediumTradingPost ||
                            building.buidlingType == monocle.Building.SmallTradingPost)
                        {
                            tradingPosts[island.id] = building.position;
                        }

                        monocle.ProductionNode productionNode;

                        if (!telegraph.GetBuildingProduction(island.id, building.id, out productionNode))
                        {
                            continue;
                        }

                        foreach (var input in productionNode.input)
                        {
                            IslandResourceData inputData = islandResource[input];
                            inputData.rate       -= Math.Max(0.1, productionNode.rate);
                            islandResource[input] = inputData;
                        }

                        IslandResourceData outputData = islandResource[productionNode.output];
                        outputData.rate += productionNode.rate;
                        islandResource[productionNode.output] = outputData;
                    }

                    islandResources.Add(island, islandResource);
                }

                List <monocle.ShipData> ships = null;

                if (!telegraph.GetAllShips(monocle.Area.OldWorld, out ships))
                {
                    return;
                }

                var             schooners     = (from ship in ships where ship.shipType == monocle.ShipType.Schooner select ship).ToList();
                List <ShipData> idleSchooners = new List <ShipData>();

                List <int> deliveriesToRemove = new List <int>();
                for (int i = 0; i < deliveries.Count; ++i)
                {
                    var shipIDs = (from s in ships select s.shipId).ToList();

                    if (!shipIDs.Contains(deliveries[i].shipID) || deliveries[i].done)
                    {
                        deliveriesToRemove.Add(i);
                    }
                }

                foreach (var schooner in schooners)
                {
                    monocle.ShipMoveData moveData;

                    if (!telegraph.GetShipMoveData(schooner.shipId, out moveData))
                    {
                        return;
                    }

                    bool schoonerInDelivery = false;

                    foreach (var delivery in deliveries)
                    {
                        if (delivery.shipID == schooner.shipId)
                        {
                            schoonerInDelivery = true;
                        }
                    }

                    if (schoonerInDelivery)
                    {
                        continue;
                    }

                    if (!moveData.moving)
                    {
                        idleSchooners.Add(schooner);
                    }
                }

                deliveriesToRemove.Reverse();

                foreach (int idx in deliveriesToRemove)
                {
                    deliveries.RemoveAt(idx);
                }

                List <Supply> supplies = new List <Supply>();
                List <Demand> demands  = new List <Demand>();

                foreach (monocle.IslandData island in islandResources.Keys)
                {
                    foreach (var r in islandResources[island].Keys)
                    {
                        int    virtualAmount = islandResources[island][r].amount;
                        int    capacity      = islandResources[island][r].capacity;
                        double ownRate       = islandResources[island][r].rate;

                        foreach (var delivery in deliveries)
                        {
                            if (delivery.targetIsland.id == island.id)
                            {
                                foreach (var package in delivery.packets)
                                {
                                    if (package.resourceType == r)
                                    {
                                        virtualAmount += package.amount;
                                    }
                                }
                            }

                            if (delivery.pickupIsland.id == island.id && !delivery.finalRun)
                            {
                                foreach (var package in delivery.packets)
                                {
                                    if (package.resourceType == r)
                                    {
                                        virtualAmount -= package.amount;
                                    }
                                }
                            }
                        }

                        if (r != Resource.Oil && r != Resource.Coal)
                        {
                            if (ownRate < 0.0 && (capacity - virtualAmount) > 50)
                            {
                                Demand demand = new Demand()
                                {
                                    island         = island,
                                    resourceType   = r,
                                    urgency        = -ownRate * (1.0 - ((double)virtualAmount / capacity)),
                                    amountDemanded = capacity - virtualAmount,
                                };

                                demands.Add(demand);
                                continue;
                            }

                            if (ownRate > 0.0 && (virtualAmount > 70) || virtualAmount == capacity)
                            {
                                Supply supply = new Supply()
                                {
                                    island         = island,
                                    resourceType   = r,
                                    amountSupplied = islandResources[island][r].amount - 20,
                                };

                                supplies.Add(supply);
                                continue;
                            }

                            if (ConstructionMaterials.ToList().Contains(r) && ownRate == 0.0)
                            {
                                int toFull = capacity - virtualAmount;

                                if (toFull < 50)
                                {
                                    continue;
                                }

                                Demand demand = new Demand()
                                {
                                    island         = island,
                                    resourceType   = r,
                                    urgency        = 1.0 / (capacity / (double)toFull),
                                    amountDemanded = toFull,
                                };

                                demands.Add(demand);
                                continue;
                            }
                        }
                    }
                }

                demands.Sort((s1, s2) => s2.urgency.CompareTo(s1.urgency));

                Console.Clear();

                foreach (Supply supply in supplies)
                {
                    Console.WriteLine(string.Format("{0} supplies {1} tonnes of {2}", supply.island.name, supply.amountSupplied.ToString(), supply.resourceType));
                }

                foreach (Demand demand in demands)
                {
                    Console.WriteLine(string.Format("{0} demands {1} tonnes of {2} at urgency {3}", demand.island.name, demand.amountDemanded.ToString(), demand.resourceType, demand.urgency));
                }

                if (idleSchooners.Count > 0 && demands.Count > 0)
                {
                    List <ResourcePacket> packets = new List <ResourcePacket>();

                    monocle.IslandData pickupIsland = new monocle.IslandData();
                    monocle.IslandData targetIsland = new monocle.IslandData();

                    bool found = false;

                    for (int i = 0; i < demands.Count; ++i)
                    {
                        var demand = demands[i];

                        if (found)
                        {
                            break;
                        }

                        for (int j = 0; j < supplies.Count; ++j)
                        {
                            var supply = supplies[j];

                            // Should not happen, but eh...
                            if (supply.island.id == demand.island.id)
                            {
                                continue;
                            }

                            if (demand.resourceType == supply.resourceType)
                            {
                                int packetSize = Math.Max(0, Math.Min(50, Math.Min(demand.amountDemanded, supply.amountSupplied)));
                                packets.Add(new ResourcePacket()
                                {
                                    resourceType = supply.resourceType, amount = packetSize
                                });
                                pickupIsland = supply.island;
                                targetIsland = demand.island;

                                demand.amountDemanded -= packetSize;
                                supply.amountSupplied -= packetSize;

                                demands[i]  = demand;
                                supplies[j] = supply;

                                found = true;
                                break;
                            }
                        }
                    }

                    if (packets.Count > 0)
                    {
                        Delivery delivery = new Delivery()
                        {
                            packets      = packets,
                            finalRun     = false,
                            done         = false,
                            pickupIsland = pickupIsland,
                            targetIsland = targetIsland,
                            shipID       = idleSchooners.First().shipId
                        };

                        Coordinate   pickupCoord = tradingPosts[pickupIsland.id];
                        List <ulong> shipID      = new List <ulong>();
                        ulong        schooner    = idleSchooners.First().shipId;
                        shipID.Add(schooner);

                        if (!telegraph.ShipDumpCargo(schooner, 0))
                        {
                            return;
                        }

                        if (!telegraph.ShipDumpCargo(schooner, 1))
                        {
                            return;
                        }

                        if (!telegraph.AddWaypoint(shipID, pickupCoord))
                        {
                            return;
                        }

                        deliveries.Add(delivery);
                    }
                }

                for (int i = 0; i < deliveries.Count; ++i)
                {
                    var delivery = deliveries[i];

                    Console.WriteLine(string.Format("Delivering {0} tonnes of {1} from {2} to {3}", delivery.packets.First().amount, delivery.packets.First().resourceType, delivery.pickupIsland.name, delivery.targetIsland.name));

                    monocle.ShipMoveData moveData;
                    if (!telegraph.GetShipMoveData(delivery.shipID, out moveData))
                    {
                        return;
                    }

                    if (moveData.moving)
                    {
                        continue;
                    }

                    monocle.Coordinate targetLocation = delivery.finalRun ? tradingPosts[delivery.targetIsland.id] : tradingPosts[delivery.pickupIsland.id];

                    double x1 = moveData.position.x;
                    double x2 = targetLocation.x;
                    double y1 = moveData.position.y;
                    double y2 = targetLocation.y;
                    double dx = x2 - x1;
                    double dy = y2 - y1;

                    double distance = Math.Sqrt(dx * dx + dy * dy);

                    if (distance > 25.0)
                    {
                        List <ulong> shipIds = new List <ulong>();
                        shipIds.Add(delivery.shipID);

                        if (!telegraph.AddWaypoint(shipIds, targetLocation))
                        {
                            return;
                        }

                        continue;
                    }

                    if (delivery.finalRun)
                    {
                        if (!telegraph.OffloadCargoFromShip(delivery.targetIsland.id, delivery.shipID, 50, 0))
                        {
                            return;
                        }

                        delivery.done = true;
                        deliveries[i] = delivery;
                    }
                    else
                    {
                        if (!telegraph.LoadCargoToShip(delivery.pickupIsland.id, delivery.shipID, delivery.packets.First().resourceType, (ulong)delivery.packets.First().amount, 0))
                        {
                            return;
                        }

                        delivery.finalRun = true;
                        deliveries[i]     = delivery;

                        List <ulong> shipIds = new List <ulong>();
                        shipIds.Add(delivery.shipID);

                        if (!telegraph.AddWaypoint(shipIds, tradingPosts[delivery.targetIsland.id]))
                        {
                            return;
                        }
                    }
                }

                Thread.Sleep(500);
            }
        }