Beispiel #1
0
    /// <summary>
    /// Carries out the order
    /// </summary>
    private void UpdateDoOrder()
    {
      GameEffect gEff = null;
      Building bldg = null;
      Tile tile = null;
      BuildingDb bldgEntry = null;
      switch (Order)
      {
        case GameObjectOrder.Idle:
          #region
          Logger.Log(string.Format("Unit #{0}:{1} finished move order", this.ObjectUID, this.Entry.Id), "Server update");

          if (!game.IsServer)
          {
            State = GameObjectState.Idle;
          }
          else
          {
            // Find position along traveling vector available for movement
            bool closeFound = false;
            if (NearestTile == null)
            {
              // Nearest Tile not yet updated
              return;
            }

            // If standing too close to other unit, move aside (if possible)
            foreach (var closeUnit in NearestTile.Units)
            {
              // Ignore self
              if (closeUnit == this) continue;
              // Ignore moving units
              if (closeUnit.State == GameObjectState.MovingToOrder) continue;
              // Check minimal distance
              if ((closeUnit.MapPosition - this.MapPosition).Length() < MIN_IDLE_DISTANCE)
              {
                Vector2 vector;
                // If the map positions aren't same, move in the same amount you are standing towards the other unit
                if (this.MapPosition != closeUnit.MapPosition)
                {
                  vector = this.MapPosition - closeUnit.MapPosition;
                  vector.Normalize();
                  OrderPosition = this.MapPosition + vector * DODGE_DISTANCE;
                }
                // If the position is same, come up with some vector
                else
                {
                  // Try to move in same amount you are standing from the origin position of the map
                  vector = this.MapPosition;
                  vector.Normalize();
                  if (NearestTile.Units.Any(q => (q.MapPosition - OrderPosition).Length() >= MOVEMENT_RANGE))
                  {
                    OrderPosition = this.MapPosition + vector * DODGE_DISTANCE;
                  }
                  // If the place is already occupied, try inverted vector and orthogonal vectors
                  else
                  {
                    Vector2 ort = new Vector2(-vector.Y, vector.X);
                    Queue<Vector2> attemptVector = new Queue<Vector2>();
                    attemptVector.Enqueue(ort); attemptVector.Enqueue(-vector);
                    attemptVector.Enqueue(-ort); attemptVector.Enqueue(vector);
                    Vector2 projectedPosition = default(Vector2);
                    while (attemptVector.Count > 0)
                    {
                      projectedPosition = this.MapPosition + attemptVector.Dequeue() * DODGE_DISTANCE;
                      if (NearestTile.Units.Any(q => (q.MapPosition - projectedPosition).Length() >= MOVEMENT_RANGE))
                        break;
                    }
                    // If everything else fails, use last failed
                    OrderPosition = projectedPosition;
                  }
                }

                State = GameObjectState.MovingToOrder;
                closeFound = true;
                game.SendData(Network.MakeServerMessage(MessageType.GameObjUpdate, this));
                break;
              }
            }
            // If there is no other unit, become idle
            if (!closeFound)
            {
              State = GameObjectState.Idle;
            }
            else
            {
              OrderTarget = null;
              OrderRange = MOVEMENT_RANGE;
            }
          }
          #endregion
          break;
        case GameObjectOrder.Attack:
          #region
          if (OrderTarget == null) return;

          if (OrderTarget == this)
          {
            CancelOrders(true);
            return;
          }

          // Animation effect
          TextureTileSet2D tex = new TextureTileSet2D(UI.Instance.GetTexture("combat"), 24, 1);
          Vector2 p = (Position + OrderTarget.Position) / 2;
          gEff = new AnimationEffect(tex, p + AlignmentOffset + Size / 2 - tex.FrameSize / 2, 24, 10, true);
          gEff.Initialize(game, NearestTile);
          this.game.Effects.Add(gEff);

          if (game.IsServer)
          {
            // Apply modifiers
            float amount = entry.AttackAmount;
            if (entry.Modifiers != null)
              for (int i = 0; i < entry.Modifiers.Length; i++)
                if (entry.Modifiers[i].Entry == OrderTarget.Entry)
                  amount *= entry.Modifiers[i].Mod;

            Logger.Log(string.Format("Unit #{0}:{1} attacking (-{2}) #{3}:{4} (before {5}/?)",
              this.ObjectUID, entry.Id, (int)amount, OrderTarget.ObjectUID, OrderTarget.Entry.Id,
              OrderTarget.Health), "Server update");

            // Apply damage
            OrderTarget.ReceiveDamage((int)amount);

            // Check whether target is alive
            if (OrderTarget.Health == 0)
            {
              CancelOrders(true);
              return;
            }
          }
          #endregion
          break;
        case GameObjectOrder.Construct:
          #region
          if (game.IsServer)
          {
            if (OrderTarget != null)
            {
              Debug.Assert(OrderTarget.GetEntityType == GameEntityType.Building);
              Logger.Log(string.Format("Unit #{0}:{1} constructing (+{2}) effect #{3}:{4} (before {5}/100)",
                this.ObjectUID, entry.Id, entry.ConstructAmount, OrderTarget.ObjectUID, OrderTarget.Entry.Id,
                ((Building)OrderTarget).Construction), "Server update");

              // Construct part of the building
              ((Building)OrderTarget).ConstructionProgress(entry.ConstructAmount);

            }
            else
            {
              Logger.Log(string.Format("Unit #{0}:{1} starting construction of {2}",
                this.ObjectUID, entry.Id, OrderEntry.Id), "Server update");
              tile = game.Map.GetTileFlat(OrderPosition);

              // Check whether building can be constructed at given position
              if (!Building.CanPlace(game.Map, tile) || Owner.Fow[tile.X, tile.Y] == 0)
              {
                Logger.Log(string.Format("Unit #{0}:{1} construction of {2} aborted - unable to place",
                  this.ObjectUID, entry.Id, OrderEntry.Id), "Server update");
                CancelOrders(true);
                return;
              }

              bldgEntry = (BuildingDb)OrderEntry;

              // Check whether building can be built more than once
              if (bldgEntry.OnlyOneAllowed && Owner.Buildings.Any(q => q.Entry == bldgEntry))
              {
                ScrollUpMessage("Only one such building allowed at a time", 100, true);
                CancelOrders(true);
                return;
              }

              if (bldgEntry.UnlockedBy != null)
              {
                bldg = Owner.Buildings.FirstOrDefault(q => q.Entry == bldgEntry.UnlockedBy);
                if (bldg == null || !bldg.Constructed)
                {
                  ScrollUpMessage("Building unavailable", 100, true);
                  CancelOrders(true);
                  return;
                }
              }

              // Check whether player canCast enough resources
              if (bldgEntry.Cost != null)
              {
                foreach (var costEntry in bldgEntry.Cost)
                {
                  if (Owner.ResourceStockpiles[costEntry.Entry] < costEntry.Amount)
                  {
                    ScrollUpMessage("Not enough resources", 100, true);
                    CancelOrders(true);
                    return;
                  }
                }
              }

              // Place new building
              bldg = new Building();
              bldg.Initialize(bldgEntry, game, Owner, tile);
              bldg.InitializeGraphics();
              game.SendData(Network.MakeServerMessage(MessageType.GameObjCreate, bldg));

              // Deduct resources from the player
              if (bldgEntry.Cost != null)
                foreach (var costEntry in bldgEntry.Cost)
                  Owner.ResourceStockpiles[costEntry.Entry] -= costEntry.Amount;

              // Set target for this unit (so it will automatically construct the building)
              OrderTarget = bldg;
              OrderEntry = null;

              game.SendData(Network.MakeServerMessage(MessageType.PlayerUpdate, Owner));
              game.SendData(Network.MakeServerMessage(MessageType.GameObjUpdate, this));
            }
          }
          #endregion
          break;
        case GameObjectOrder.Spell:
          #region
          EffectDb effect = (EffectDb)OrderEntry;
          if (game.IsServer)
          {
            // Check whether spell can be cast
            if (effect.UnlockedBy != null)
            {
              bldg = Owner.Buildings.FirstOrDefault(q => q.Entry == effect.UnlockedBy);
              if (bldg == null || !bldg.Constructed)
              {
                CancelOrders(true);
                return;
              }
            }

            Logger.Log(string.Format("Unit #{0}:{1} casting {2}", this.ObjectUID, entry.Id, OrderEntry.Id), "Server update");
            switch (effect.Spell.Target)
            {
              case SpellEntry.TargetType.Tile:
                tile = game.Map.GetTileFlat(OrderPosition);
                gEff = new GameEffect(effect, this, tile);
                gEff.Initialize(game, tile);
                this.game.Effects.Add(gEff);
                break;
              case SpellEntry.TargetType.GameEntity:
                Debug.Assert(OrderTarget != null);
                gEff = new GameEffect(effect, this, OrderTarget);
                gEff.Initialize(game, OrderTarget.NearestTile);
                this.game.Effects.Add(gEff);
                break;
              default:
                throw new Exception("Undefined spell type");
            }
            game.SendData(Network.MakeServerMessage(MessageType.GameEffectCreate, gEff));
          }
          if (!effect.AutoRepeat)
          {
            State = GameObjectState.Idle;
          }
          #endregion
          break;
        case GameObjectOrder.Gather:
          #region
          if (OrderTarget.GetEntityType == GameEntityType.Building)
          {
            Debug.Assert(carryType != null);

            if (carryAmount > 0)
            {
              ScrollUpMessage(string.Format("Returned {0} of {1}", carryAmount, carryType.Name), 50);
            }

            if (game.IsServer)
            {
              // First zoneFound only transfers carried resources and sets order delay, second time around unit moves back to resource
              if (carryAmount > 0)
              {
                Debug.Assert(((BuildingDb)OrderTarget.Entry).ResourceCenter);

                Logger.Log(string.Format("Unit #{0}:{1} returned +{2} of {3} (before {4}) to #{5}:{6}",
                  this.ObjectUID, this.Entry.Id, carryAmount, carryType.Id, Owner.ResourceStockpiles[carryType],
                  OrderTarget.ObjectUID, OrderTarget.Entry.Id), "Server update");

                // Give resources to player
                Owner.ResourceStockpiles[carryType] += carryAmount;
                carryAmount = 0;
                OrderTimeout = GATHER_RETURN_DELAY;

                game.SendData(Network.MakeServerMessage(MessageType.GameObjUpdate, this));
                game.SendData(Network.MakeServerMessage(MessageType.PlayerUpdate, Owner));
              }
              else
              {
                if (lastGatheredResource.Amount == 0)
                {
                  CancelOrders(true);
                  return;
                }
                // Head towards resource
                Debug.Assert(lastGatheredResource != null);
                OrderTarget = lastGatheredResource;
                OrderRange = entry.GatherRange;
                OrderTimeout = entry.GatherSpeed;

                game.SendData(Network.MakeServerMessage(MessageType.GameObjUpdate, this));
              }
            }
          }
          else if (OrderTarget.GetEntityType == GameEntityType.Resource)
          {
            Debug.Assert(carryAmount == 0 || carryType == (ResourceDb)OrderTarget.Entry);
            Resource res = (Resource)OrderTarget;

            if (res.Cooldown > 0) break;

            if (game.IsServer)
            {

              if (carryAmount == 0)
              {
                carryType = (ResourceDb)res.Entry;
              }

              if (res.Amount == 0)
              {
                CancelOrders(true);
                return;
              }

              int take = res.Take(entry.GatherAmount);

              Logger.Log(string.Format("Unit #{0}:{1} gathered +{2} of {3} (before {4}) from #{5}:{6}",
                this.ObjectUID, this.Entry.Id, take, carryType.Id, carryAmount,
                OrderTarget.ObjectUID, OrderTarget.Entry.Id), "Server update");

              carryAmount += take;

              game.SendData(Network.MakeServerMessage(MessageType.GameObjUpdate, res));
              ScrollUpMessage(string.Format("Gathered {0} of {1}", take, OrderTarget.Entry.Name), 30, true);
            }
          }
          else
          {
            CancelOrders(true);
          }

          #endregion
          break;
        case GameObjectOrder.Train:
          #region
          if (game.IsServer)
          {
            bldg = (Building)OrderTarget;
            // If the building is already training, wait
            if (bldg.Spawner != null && bldg.Spawner.Active) break;
            bldgEntry = (BuildingDb)bldg.Entry;

            bool noEntry = true;
            BuildingDb.TrainEntry trainEntry = default(BuildingDb.TrainEntry);
            if (bldgEntry.Trains != null)
            {
              foreach (var iterTrainEntry in bldgEntry.Trains)
              {
                if (iterTrainEntry.TrainFrom == this.entry)
                {
                  noEntry = false;
                  trainEntry = iterTrainEntry;
                  break;
                }
              }
            }

            if (noEntry)
            {
              ScrollUpMessage("Unable to train this unit in this building", 100, true);
              CancelOrders(true);
              return;
            }

            // Check whether player canCast enough resources
            if (trainEntry.Cost != null)
            {
              foreach (var costEntry in trainEntry.Cost)
              {
                if (Owner.ResourceStockpiles[costEntry.Entry] < costEntry.Amount)
                {
                  ScrollUpMessage("Not enough resources", 100, true);
                  CancelOrders(true);
                  return;
                }
              }
            }

            Logger.Log(string.Format("Unit #{0}:{1} start training in #{2}:{3} towards {4}",
              this.ObjectUID, this.Entry.Id, OrderTarget.ObjectUID, OrderTarget.Entry.Id, bldgEntry.Id), "Server update");

            // Initialize spawning of the new unit
            bldg.StartUnitSpawner(trainEntry.TrainTo, trainEntry.Speed);

            // Deduct resources from the player
            if (trainEntry.Cost != null)
              foreach (var costEntry in trainEntry.Cost)
                Owner.ResourceStockpiles[costEntry.Entry] -= costEntry.Amount;
            game.SendData(Network.MakeServerMessage(MessageType.PlayerUpdate, Owner));

            // Info newText
            gEff = new ScrollTextEffect("Training", Position, 50, new Vector2(0, -1));
            gEff.Initialize(game, bldg.NearestTile);
            this.game.Effects.Add(gEff);
            game.SendData(Network.MakeServerMessage(MessageType.GameEffectCreate, gEff));

            // Kill the unit
            Kill(true);
            return;
          }
          #endregion
          break;
      }
    }
Beispiel #2
0
    /// <summary>
    /// Creates an animation effect
    /// </summary>
    /// <param id="tile">Tile where the effect will be created</param>
    /// <param id="duration">How long the effect will last</param>
    /// <param id="speed">How fast the animation will go through the frames</param>
    /// <param id="texture">Texture of the animation</param>
    /// <param id="frames">Frames per row in the texture</param>
    /// <param id="rows">Frames per column in the texture</param>
    /// <param id="activeRow">Active row for animation</param>
    /// <param id="overlay">Specifies in which zoneFound the animation should be drawn</param>
    public void CreateAnimationEffect(IScriptTile tile, int duration, int speed, string texture, int frames, int rows, int activeRow, bool overlay)
    {
      Tile tileCasted = (Tile)tile;

      float x = tileCasted.MapPosition.X;
      float y = tileCasted.MapPosition.Y - tileCasted.Elevation * MapBoard.ELEVATION_SCALING;
      Vector2 position = new Vector2(x, y).Round();

      TextureTileSet2D tex = new TextureTileSet2D(UI.Instance.GetTexture(texture), frames, rows);
      tex.SetRow(activeRow);

      GameEffect gEff = new AnimationEffect(tex, position + MapBoard.TILE_SIZE / 2 - tex.FrameSize/2, duration, speed, overlay);
      gEff.Initialize(this, tileCasted);
      this.Effects.Add(gEff);
      SendData(Network.MakeServerMessage(MessageType.GameEffectCreate, gEff));
    }
Beispiel #3
0
 /// <summary>
 /// Creates a new instance of the GameEffect class using the serialized data
 /// </summary>
 /// <param id="line">String array containing the serialized data</param>
 /// <param id="position">Current position in the array</param>
 /// <param id="context">Context of the serialized data, game where this INetworkSerializable object is in</param>
 /// <returns>GameEffect created using the provided serialized data</returns>
 public static GameEffect Create(string[] line, ref int position, WildmenGame context)
 {
   GameEffect e = null;
   EffectTypes et = (EffectTypes)int.Parse(line[position++]);
   switch (et)
   {
     case EffectTypes.Scripted:
       e = new GameEffect();
       break;
     case EffectTypes.UnitDeath:
       e = new UnitDeathEffect();
       break;
     case EffectTypes.ScrollText:
       e = new ScrollTextEffect();
       break;
     case EffectTypes.Animation:
       e = new AnimationEffect();
       break;
     case EffectTypes.Spawner:
       e = new SpawnerEffect();
       break;
     default:
       throw new Exception("Unknown effect");
   }
   e.game = context;
   e.Deserialize(MessageType.GameEffectCreate, line, ref position, context);
   return e;
 }