// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: OuterMessage.proto
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using scg = global::System.Collections.Generic;
namespace KYFramework.Network {

  #region Messages
  public partial class C2R_Ping : pb::IMessage {
    private static readonly pb::MessageParser<C2R_Ping> _parser = new pb::MessageParser<C2R_Ping>(() => (C2R_Ping)MessagePool.Instance.Fetch(typeof(C2R_Ping)));
    public static pb::MessageParser<C2R_Ping> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(208, 5);
        output.WriteInt32(RpcId);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 720: {
            RpcId = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  public partial class R2C_Ping : pb::IMessage {
    private static readonly pb::MessageParser<R2C_Ping> _parser = new pb::MessageParser<R2C_Ping>(() => (R2C_Ping)MessagePool.Instance.Fetch(typeof(R2C_Ping)));
    public static pb::MessageParser<R2C_Ping> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    private int error_;
    public int Error {
      get { return error_; }
      set {
        error_ = value;
      }
    }

    private string message_ = "";
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(208, 5);
        output.WriteInt32(RpcId);
      }
      if (Error != 0) {
        output.WriteRawTag(216, 5);
        output.WriteInt32(Error);
      }
      if (Message.Length != 0) {
        output.WriteRawTag(226, 5);
        output.WriteString(Message);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      if (Error != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(Error);
      }
      if (Message.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      error_ = 0;
      message_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 720: {
            RpcId = input.ReadInt32();
            break;
          }
          case 728: {
            Error = input.ReadInt32();
            break;
          }
          case 738: {
            Message = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public partial class C2S_Test : pb::IMessage {
    private static readonly pb::MessageParser<C2S_Test> _parser = new pb::MessageParser<C2S_Test>(() => (C2S_Test)MessagePool.Instance.Fetch(typeof(C2S_Test)));
    public static pb::MessageParser<C2S_Test> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    private string message_ = "";
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(208, 5);
        output.WriteInt32(RpcId);
      }
      if (Message.Length != 0) {
        output.WriteRawTag(226, 5);
        output.WriteString(Message);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      if (Message.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      message_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 720: {
            RpcId = input.ReadInt32();
            break;
          }
          case 738: {
            Message = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public partial class S2C_Test : pb::IMessage {
    private static readonly pb::MessageParser<S2C_Test> _parser = new pb::MessageParser<S2C_Test>(() => (S2C_Test)MessagePool.Instance.Fetch(typeof(S2C_Test)));
    public static pb::MessageParser<S2C_Test> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    private int error_;
    public int Error {
      get { return error_; }
      set {
        error_ = value;
      }
    }

    private string message_ = "";
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(208, 5);
        output.WriteInt32(RpcId);
      }
      if (Error != 0) {
        output.WriteRawTag(216, 5);
        output.WriteInt32(Error);
      }
      if (Message.Length != 0) {
        output.WriteRawTag(226, 5);
        output.WriteString(Message);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      if (Error != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(Error);
      }
      if (Message.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      error_ = 0;
      message_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 720: {
            RpcId = input.ReadInt32();
            break;
          }
          case 728: {
            Error = input.ReadInt32();
            break;
          }
          case 738: {
            Message = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public partial class C2S_TestMessage : pb::IMessage {
    private static readonly pb::MessageParser<C2S_TestMessage> _parser = new pb::MessageParser<C2S_TestMessage>(() => (C2S_TestMessage)MessagePool.Instance.Fetch(typeof(C2S_TestMessage)));
    public static pb::MessageParser<C2S_TestMessage> Parser { get { return _parser; } }

    private string message_ = "";
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Message.Length != 0) {
        output.WriteRawTag(210, 5);
        output.WriteString(Message);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (Message.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      message_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 722: {
            Message = input.ReadString();
            break;
          }
        }
      }
    }

  }

  public partial class S2C_TestMessage : pb::IMessage {
    private static readonly pb::MessageParser<S2C_TestMessage> _parser = new pb::MessageParser<S2C_TestMessage>(() => (S2C_TestMessage)MessagePool.Instance.Fetch(typeof(S2C_TestMessage)));
    public static pb::MessageParser<S2C_TestMessage> Parser { get { return _parser; } }

    private string message_ = "";
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Message.Length != 0) {
        output.WriteRawTag(210, 5);
        output.WriteString(Message);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (Message.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      message_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 722: {
            Message = input.ReadString();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 地理点：经纬高 
  /// </summary>
  public partial class Point : pb::IMessage {
    private static readonly pb::MessageParser<Point> _parser = new pb::MessageParser<Point>(() => (Point)MessagePool.Instance.Fetch(typeof(Point)));
    public static pb::MessageParser<Point> Parser { get { return _parser; } }

    private double longitude_;
    public double Longitude {
      get { return longitude_; }
      set {
        longitude_ = value;
      }
    }

    private double latitude_;
    public double Latitude {
      get { return latitude_; }
      set {
        latitude_ = value;
      }
    }

    private double altitude_;
    public double Altitude {
      get { return altitude_; }
      set {
        altitude_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Longitude != 0D) {
        output.WriteRawTag(9);
        output.WriteDouble(Longitude);
      }
      if (Latitude != 0D) {
        output.WriteRawTag(17);
        output.WriteDouble(Latitude);
      }
      if (Altitude != 0D) {
        output.WriteRawTag(25);
        output.WriteDouble(Altitude);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (Longitude != 0D) {
        size += 1 + 8;
      }
      if (Latitude != 0D) {
        size += 1 + 8;
      }
      if (Altitude != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 9: {
            Longitude = input.ReadDouble();
            break;
          }
          case 17: {
            Latitude = input.ReadDouble();
            break;
          }
          case 25: {
            Altitude = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 基地 
  /// </summary>
  public partial class Base : pb::IMessage {
    private static readonly pb::MessageParser<Base> _parser = new pb::MessageParser<Base>(() => (Base)MessagePool.Instance.Fetch(typeof(Base)));
    public static pb::MessageParser<Base> Parser { get { return _parser; } }

    private string baseName_ = "";
    public string BaseName {
      get { return baseName_; }
      set {
        baseName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private global::KYFramework.Network.Point baseLocation_;
    public global::KYFramework.Network.Point BaseLocation {
      get { return baseLocation_; }
      set {
        baseLocation_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (BaseName.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(BaseName);
      }
      if (baseLocation_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(BaseLocation);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (BaseName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(BaseName);
      }
      if (baseLocation_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(BaseLocation);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      baseName_ = "";
      if (baseLocation_ != null) MessagePool.Instance.Recycle(baseLocation_); baseLocation_ = null;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            BaseName = input.ReadString();
            break;
          }
          case 18: {
            if (baseLocation_ == null) {
              baseLocation_ = new global::KYFramework.Network.Point();
            }
            input.ReadMessage(baseLocation_);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 行政区气象数据 
  /// </summary>
  public partial class CityWeather : pb::IMessage {
    private static readonly pb::MessageParser<CityWeather> _parser = new pb::MessageParser<CityWeather>(() => (CityWeather)MessagePool.Instance.Fetch(typeof(CityWeather)));
    public static pb::MessageParser<CityWeather> Parser { get { return _parser; } }

    private string cityName_ = "";
    /// <summary>
    /// 行政区域名称：XX市 
    /// </summary>
    public string CityName {
      get { return cityName_; }
      set {
        cityName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string weatherCondition_ = "";
    /// <summary>
    /// 天气状况：晴/多云/雨等 
    /// </summary>
    public string WeatherCondition {
      get { return weatherCondition_; }
      set {
        weatherCondition_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string windDirection_ = "";
    /// <summary>
    /// 风向：东南西北 
    /// </summary>
    public string WindDirection {
      get { return windDirection_; }
      set {
        windDirection_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private double windVelocity_;
    /// <summary>
    /// 风速 
    /// </summary>
    public double WindVelocity {
      get { return windVelocity_; }
      set {
        windVelocity_ = value;
      }
    }

    private double temperature_;
    /// <summary>
    /// 温度 
    /// </summary>
    public double Temperature {
      get { return temperature_; }
      set {
        temperature_ = value;
      }
    }

    private double humidity_;
    /// <summary>
    /// 湿度 
    /// </summary>
    public double Humidity {
      get { return humidity_; }
      set {
        humidity_ = value;
      }
    }

    private double visibility_;
    /// <summary>
    /// 能见度 
    /// </summary>
    public double Visibility {
      get { return visibility_; }
      set {
        visibility_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (CityName.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(CityName);
      }
      if (WeatherCondition.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(WeatherCondition);
      }
      if (WindDirection.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(WindDirection);
      }
      if (WindVelocity != 0D) {
        output.WriteRawTag(33);
        output.WriteDouble(WindVelocity);
      }
      if (Temperature != 0D) {
        output.WriteRawTag(41);
        output.WriteDouble(Temperature);
      }
      if (Humidity != 0D) {
        output.WriteRawTag(49);
        output.WriteDouble(Humidity);
      }
      if (Visibility != 0D) {
        output.WriteRawTag(57);
        output.WriteDouble(Visibility);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (CityName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(CityName);
      }
      if (WeatherCondition.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(WeatherCondition);
      }
      if (WindDirection.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(WindDirection);
      }
      if (WindVelocity != 0D) {
        size += 1 + 8;
      }
      if (Temperature != 0D) {
        size += 1 + 8;
      }
      if (Humidity != 0D) {
        size += 1 + 8;
      }
      if (Visibility != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      cityName_ = "";
      weatherCondition_ = "";
      windDirection_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            CityName = input.ReadString();
            break;
          }
          case 18: {
            WeatherCondition = input.ReadString();
            break;
          }
          case 26: {
            WindDirection = input.ReadString();
            break;
          }
          case 33: {
            WindVelocity = input.ReadDouble();
            break;
          }
          case 41: {
            Temperature = input.ReadDouble();
            break;
          }
          case 49: {
            Humidity = input.ReadDouble();
            break;
          }
          case 57: {
            Visibility = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 航线 
  /// </summary>
  public partial class AirRoute : pb::IMessage {
    private static readonly pb::MessageParser<AirRoute> _parser = new pb::MessageParser<AirRoute>(() => (AirRoute)MessagePool.Instance.Fetch(typeof(AirRoute)));
    public static pb::MessageParser<AirRoute> Parser { get { return _parser; } }

    private string name_ = "";
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.Point> _repeated_pointArr_codec
        = pb::FieldCodec.ForMessage(18, global::KYFramework.Network.Point.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.Point> pointArr_ = new pbc::RepeatedField<global::KYFramework.Network.Point>();
    public pbc::RepeatedField<global::KYFramework.Network.Point> PointArr {
      get { return pointArr_; }
      set { pointArr_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      pointArr_.WriteTo(output, _repeated_pointArr_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      size += pointArr_.CalculateSize(_repeated_pointArr_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      name_ = "";
      for (int i = 0; i < pointArr_.Count; i++) { MessagePool.Instance.Recycle(pointArr_[i]); }
      pointArr_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18: {
            pointArr_.AddEntriesFrom(input, _repeated_pointArr_codec);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 圆形禁飞区 
  /// </summary>
  public partial class NoFlyZoneCircle : pb::IMessage {
    private static readonly pb::MessageParser<NoFlyZoneCircle> _parser = new pb::MessageParser<NoFlyZoneCircle>(() => (NoFlyZoneCircle)MessagePool.Instance.Fetch(typeof(NoFlyZoneCircle)));
    public static pb::MessageParser<NoFlyZoneCircle> Parser { get { return _parser; } }

    private string noFlyZoneType_ = "";
    public string NoFlyZoneType {
      get { return noFlyZoneType_; }
      set {
        noFlyZoneType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private global::KYFramework.Network.Point noFlyZoneCenterLocation_;
    public global::KYFramework.Network.Point NoFlyZoneCenterLocation {
      get { return noFlyZoneCenterLocation_; }
      set {
        noFlyZoneCenterLocation_ = value;
      }
    }

    private double noFlyZoneRadius_;
    public double NoFlyZoneRadius {
      get { return noFlyZoneRadius_; }
      set {
        noFlyZoneRadius_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (NoFlyZoneType.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(NoFlyZoneType);
      }
      if (noFlyZoneCenterLocation_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(NoFlyZoneCenterLocation);
      }
      if (NoFlyZoneRadius != 0D) {
        output.WriteRawTag(25);
        output.WriteDouble(NoFlyZoneRadius);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (NoFlyZoneType.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(NoFlyZoneType);
      }
      if (noFlyZoneCenterLocation_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(NoFlyZoneCenterLocation);
      }
      if (NoFlyZoneRadius != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      noFlyZoneType_ = "";
      if (noFlyZoneCenterLocation_ != null) MessagePool.Instance.Recycle(noFlyZoneCenterLocation_); noFlyZoneCenterLocation_ = null;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            NoFlyZoneType = input.ReadString();
            break;
          }
          case 18: {
            if (noFlyZoneCenterLocation_ == null) {
              noFlyZoneCenterLocation_ = new global::KYFramework.Network.Point();
            }
            input.ReadMessage(noFlyZoneCenterLocation_);
            break;
          }
          case 25: {
            NoFlyZoneRadius = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 矩形禁飞区 
  /// </summary>
  public partial class NoFlyZoneRect : pb::IMessage {
    private static readonly pb::MessageParser<NoFlyZoneRect> _parser = new pb::MessageParser<NoFlyZoneRect>(() => (NoFlyZoneRect)MessagePool.Instance.Fetch(typeof(NoFlyZoneRect)));
    public static pb::MessageParser<NoFlyZoneRect> Parser { get { return _parser; } }

    private string noFlyZoneType_ = "";
    public string NoFlyZoneType {
      get { return noFlyZoneType_; }
      set {
        noFlyZoneType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.Point> _repeated_noFlyZoneRectangleLocation_codec
        = pb::FieldCodec.ForMessage(18, global::KYFramework.Network.Point.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.Point> noFlyZoneRectangleLocation_ = new pbc::RepeatedField<global::KYFramework.Network.Point>();
    public pbc::RepeatedField<global::KYFramework.Network.Point> NoFlyZoneRectangleLocation {
      get { return noFlyZoneRectangleLocation_; }
      set { noFlyZoneRectangleLocation_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (NoFlyZoneType.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(NoFlyZoneType);
      }
      noFlyZoneRectangleLocation_.WriteTo(output, _repeated_noFlyZoneRectangleLocation_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (NoFlyZoneType.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(NoFlyZoneType);
      }
      size += noFlyZoneRectangleLocation_.CalculateSize(_repeated_noFlyZoneRectangleLocation_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      noFlyZoneType_ = "";
      for (int i = 0; i < noFlyZoneRectangleLocation_.Count; i++) { MessagePool.Instance.Recycle(noFlyZoneRectangleLocation_[i]); }
      noFlyZoneRectangleLocation_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            NoFlyZoneType = input.ReadString();
            break;
          }
          case 18: {
            noFlyZoneRectangleLocation_.AddEntriesFrom(input, _repeated_noFlyZoneRectangleLocation_codec);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 爬升航段 
  /// </summary>
  public partial class ClimbSegment : pb::IMessage {
    private static readonly pb::MessageParser<ClimbSegment> _parser = new pb::MessageParser<ClimbSegment>(() => (ClimbSegment)MessagePool.Instance.Fetch(typeof(ClimbSegment)));
    public static pb::MessageParser<ClimbSegment> Parser { get { return _parser; } }

    private double climbVelocity_;
    public double ClimbVelocity {
      get { return climbVelocity_; }
      set {
        climbVelocity_ = value;
      }
    }

    private double climbFuelConsumptionRate_;
    public double ClimbFuelConsumptionRate {
      get { return climbFuelConsumptionRate_; }
      set {
        climbFuelConsumptionRate_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (ClimbVelocity != 0D) {
        output.WriteRawTag(9);
        output.WriteDouble(ClimbVelocity);
      }
      if (ClimbFuelConsumptionRate != 0D) {
        output.WriteRawTag(17);
        output.WriteDouble(ClimbFuelConsumptionRate);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (ClimbVelocity != 0D) {
        size += 1 + 8;
      }
      if (ClimbFuelConsumptionRate != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 9: {
            ClimbVelocity = input.ReadDouble();
            break;
          }
          case 17: {
            ClimbFuelConsumptionRate = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 下降航段 
  /// </summary>
  public partial class DescentSegment : pb::IMessage {
    private static readonly pb::MessageParser<DescentSegment> _parser = new pb::MessageParser<DescentSegment>(() => (DescentSegment)MessagePool.Instance.Fetch(typeof(DescentSegment)));
    public static pb::MessageParser<DescentSegment> Parser { get { return _parser; } }

    private double descentVelocity_;
    public double DescentVelocity {
      get { return descentVelocity_; }
      set {
        descentVelocity_ = value;
      }
    }

    private double descentFuelConsumptionRate_;
    public double DescentFuelConsumptionRate {
      get { return descentFuelConsumptionRate_; }
      set {
        descentFuelConsumptionRate_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (DescentVelocity != 0D) {
        output.WriteRawTag(9);
        output.WriteDouble(DescentVelocity);
      }
      if (DescentFuelConsumptionRate != 0D) {
        output.WriteRawTag(17);
        output.WriteDouble(DescentFuelConsumptionRate);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (DescentVelocity != 0D) {
        size += 1 + 8;
      }
      if (DescentFuelConsumptionRate != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 9: {
            DescentVelocity = input.ReadDouble();
            break;
          }
          case 17: {
            DescentFuelConsumptionRate = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 巡航航段 
  /// </summary>
  public partial class CruiseSegment : pb::IMessage {
    private static readonly pb::MessageParser<CruiseSegment> _parser = new pb::MessageParser<CruiseSegment>(() => (CruiseSegment)MessagePool.Instance.Fetch(typeof(CruiseSegment)));
    public static pb::MessageParser<CruiseSegment> Parser { get { return _parser; } }

    private double cruiseAltitude_;
    public double CruiseAltitude {
      get { return cruiseAltitude_; }
      set {
        cruiseAltitude_ = value;
      }
    }

    private double cruiseVelocity_;
    public double CruiseVelocity {
      get { return cruiseVelocity_; }
      set {
        cruiseVelocity_ = value;
      }
    }

    private double cruiseFuelConsumptionRate_;
    public double CruiseFuelConsumptionRate {
      get { return cruiseFuelConsumptionRate_; }
      set {
        cruiseFuelConsumptionRate_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (CruiseAltitude != 0D) {
        output.WriteRawTag(9);
        output.WriteDouble(CruiseAltitude);
      }
      if (CruiseVelocity != 0D) {
        output.WriteRawTag(17);
        output.WriteDouble(CruiseVelocity);
      }
      if (CruiseFuelConsumptionRate != 0D) {
        output.WriteRawTag(25);
        output.WriteDouble(CruiseFuelConsumptionRate);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (CruiseAltitude != 0D) {
        size += 1 + 8;
      }
      if (CruiseVelocity != 0D) {
        size += 1 + 8;
      }
      if (CruiseFuelConsumptionRate != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 9: {
            CruiseAltitude = input.ReadDouble();
            break;
          }
          case 17: {
            CruiseVelocity = input.ReadDouble();
            break;
          }
          case 25: {
            CruiseFuelConsumptionRate = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 转弯航段 
  /// </summary>
  public partial class TurningSegment : pb::IMessage {
    private static readonly pb::MessageParser<TurningSegment> _parser = new pb::MessageParser<TurningSegment>(() => (TurningSegment)MessagePool.Instance.Fetch(typeof(TurningSegment)));
    public static pb::MessageParser<TurningSegment> Parser { get { return _parser; } }

    private double turningRadius_;
    public double TurningRadius {
      get { return turningRadius_; }
      set {
        turningRadius_ = value;
      }
    }

    private double turningVelocity_;
    public double TurningVelocity {
      get { return turningVelocity_; }
      set {
        turningVelocity_ = value;
      }
    }

    private double climbFuelConsumptionRate_;
    public double ClimbFuelConsumptionRate {
      get { return climbFuelConsumptionRate_; }
      set {
        climbFuelConsumptionRate_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (TurningRadius != 0D) {
        output.WriteRawTag(9);
        output.WriteDouble(TurningRadius);
      }
      if (TurningVelocity != 0D) {
        output.WriteRawTag(17);
        output.WriteDouble(TurningVelocity);
      }
      if (ClimbFuelConsumptionRate != 0D) {
        output.WriteRawTag(25);
        output.WriteDouble(ClimbFuelConsumptionRate);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (TurningRadius != 0D) {
        size += 1 + 8;
      }
      if (TurningVelocity != 0D) {
        size += 1 + 8;
      }
      if (ClimbFuelConsumptionRate != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 9: {
            TurningRadius = input.ReadDouble();
            break;
          }
          case 17: {
            TurningVelocity = input.ReadDouble();
            break;
          }
          case 25: {
            ClimbFuelConsumptionRate = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 飞行计划编辑器（输入） 
  /// </summary>
  public partial class C2S_FlyPlanInput : pb::IMessage {
    private static readonly pb::MessageParser<C2S_FlyPlanInput> _parser = new pb::MessageParser<C2S_FlyPlanInput>(() => (C2S_FlyPlanInput)MessagePool.Instance.Fetch(typeof(C2S_FlyPlanInput)));
    public static pb::MessageParser<C2S_FlyPlanInput> Parser { get { return _parser; } }

    private string missionName_ = "";
    /// <summary>
    /// 任务名称 
    /// </summary>
    public string MissionName {
      get { return missionName_; }
      set {
        missionName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string missionType_ = "";
    /// <summary>
    /// 任务类型 
    /// </summary>
    public string MissionType {
      get { return missionType_; }
      set {
        missionType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.Point> _repeated_missionRectangle_codec
        = pb::FieldCodec.ForMessage(26, global::KYFramework.Network.Point.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.Point> missionRectangle_ = new pbc::RepeatedField<global::KYFramework.Network.Point>();
    /// <summary>
    /// 任务矩形区域顶点集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.Point> MissionRectangle {
      get { return missionRectangle_; }
      set { missionRectangle_ = value; }
    }

    private double maxTakeoffWeight_;
    /// <summary>
    /// 最大起飞重量 
    /// </summary>
    public double MaxTakeoffWeight {
      get { return maxTakeoffWeight_; }
      set {
        maxTakeoffWeight_ = value;
      }
    }

    private double takeoffEmptyWeight_;
    /// <summary>
    /// 起飞空重 
    /// </summary>
    public double TakeoffEmptyWeight {
      get { return takeoffEmptyWeight_; }
      set {
        takeoffEmptyWeight_ = value;
      }
    }

    private double maxFlightRange_;
    /// <summary>
    /// 最大航程 
    /// </summary>
    public double MaxFlightRange {
      get { return maxFlightRange_; }
      set {
        maxFlightRange_ = value;
      }
    }

    private double maxFlightTime_;
    /// <summary>
    /// 续航时间 
    /// </summary>
    public double MaxFlightTime {
      get { return maxFlightTime_; }
      set {
        maxFlightTime_ = value;
      }
    }

    private double serviceCeiling_;
    /// <summary>
    /// 实用升限 
    /// </summary>
    public double ServiceCeiling {
      get { return serviceCeiling_; }
      set {
        serviceCeiling_ = value;
      }
    }

    private double maxFuelCapacity_;
    /// <summary>
    /// 最大载油量 
    /// </summary>
    public double MaxFuelCapacity {
      get { return maxFuelCapacity_; }
      set {
        maxFuelCapacity_ = value;
      }
    }

    private double maxWeightCapacity_;
    /// <summary>
    /// 最大商载量 
    /// </summary>
    public double MaxWeightCapacity {
      get { return maxWeightCapacity_; }
      set {
        maxWeightCapacity_ = value;
      }
    }

    private string loadName_ = "";
    /// <summary>
    /// 载荷名称 
    /// </summary>
    public string LoadName {
      get { return loadName_; }
      set {
        loadName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private int loadQuantity_;
    /// <summary>
    /// 载荷数量 
    /// </summary>
    public int LoadQuantity {
      get { return loadQuantity_; }
      set {
        loadQuantity_ = value;
      }
    }

    private double loadWeight_;
    /// <summary>
    /// 载荷重量 
    /// </summary>
    public double LoadWeight {
      get { return loadWeight_; }
      set {
        loadWeight_ = value;
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.CityWeather> _repeated_cityWeatherArr_codec
        = pb::FieldCodec.ForMessage(114, global::KYFramework.Network.CityWeather.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.CityWeather> cityWeatherArr_ = new pbc::RepeatedField<global::KYFramework.Network.CityWeather>();
    /// <summary>
    /// 行政区气象集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.CityWeather> CityWeatherArr {
      get { return cityWeatherArr_; }
      set { cityWeatherArr_ = value; }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.Base> _repeated_baseArr_codec
        = pb::FieldCodec.ForMessage(122, global::KYFramework.Network.Base.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.Base> baseArr_ = new pbc::RepeatedField<global::KYFramework.Network.Base>();
    /// <summary>
    /// 基地集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.Base> BaseArr {
      get { return baseArr_; }
      set { baseArr_ = value; }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.AirRoute> _repeated_airRouteArr_codec
        = pb::FieldCodec.ForMessage(130, global::KYFramework.Network.AirRoute.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.AirRoute> airRouteArr_ = new pbc::RepeatedField<global::KYFramework.Network.AirRoute>();
    /// <summary>
    /// 航线集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.AirRoute> AirRouteArr {
      get { return airRouteArr_; }
      set { airRouteArr_ = value; }
    }

    private string endSelection_ = "";
    /// <summary>
    /// 任务终点选择：Base代表返回基地，Point代表前往定点，Hover代表原地盘旋等待 
    /// </summary>
    public string EndSelection {
      get { return endSelection_; }
      set {
        endSelection_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.Point> _repeated_terminusLocation_codec
        = pb::FieldCodec.ForMessage(146, global::KYFramework.Network.Point.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.Point> terminusLocation_ = new pbc::RepeatedField<global::KYFramework.Network.Point>();
    /// <summary>
    /// 终点位置集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.Point> TerminusLocation {
      get { return terminusLocation_; }
      set { terminusLocation_ = value; }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.NoFlyZoneCircle> _repeated_noFlyZoneCircleArr_codec
        = pb::FieldCodec.ForMessage(154, global::KYFramework.Network.NoFlyZoneCircle.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.NoFlyZoneCircle> noFlyZoneCircleArr_ = new pbc::RepeatedField<global::KYFramework.Network.NoFlyZoneCircle>();
    /// <summary>
    /// 圆形禁飞区集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.NoFlyZoneCircle> NoFlyZoneCircleArr {
      get { return noFlyZoneCircleArr_; }
      set { noFlyZoneCircleArr_ = value; }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.NoFlyZoneRect> _repeated_noFlyZoneRectArr_codec
        = pb::FieldCodec.ForMessage(162, global::KYFramework.Network.NoFlyZoneRect.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.NoFlyZoneRect> noFlyZoneRectArr_ = new pbc::RepeatedField<global::KYFramework.Network.NoFlyZoneRect>();
    /// <summary>
    /// 矩形禁飞区集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.NoFlyZoneRect> NoFlyZoneRectArr {
      get { return noFlyZoneRectArr_; }
      set { noFlyZoneRectArr_ = value; }
    }

    private double visualDistance_;
    /// <summary>
    /// 目视距离 
    /// </summary>
    public double VisualDistance {
      get { return visualDistance_; }
      set {
        visualDistance_ = value;
      }
    }

    private string detourDirection_ = "";
    /// <summary>
    /// 火场绕行方向：Clockwise表示顺时针，Anticlockwise表示逆时针 
    /// </summary>
    public string DetourDirection {
      get { return detourDirection_; }
      set {
        detourDirection_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private int numberOfDetour_;
    /// <summary>
    /// 火场绕行圈数 
    /// </summary>
    public int NumberOfDetour {
      get { return numberOfDetour_; }
      set {
        numberOfDetour_ = value;
      }
    }

    private double detourIntervalDistance_;
    /// <summary>
    /// 绕行间隔距离 
    /// </summary>
    public double DetourIntervalDistance {
      get { return detourIntervalDistance_; }
      set {
        detourIntervalDistance_ = value;
      }
    }

    private double detourVelocity_;
    /// <summary>
    /// 绕行速度 
    /// </summary>
    public double DetourVelocity {
      get { return detourVelocity_; }
      set {
        detourVelocity_ = value;
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.Point> _repeated_firePointLocation_codec
        = pb::FieldCodec.ForMessage(210, global::KYFramework.Network.Point.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.Point> firePointLocation_ = new pbc::RepeatedField<global::KYFramework.Network.Point>();
    /// <summary>
    /// 火点位置集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.Point> FirePointLocation {
      get { return firePointLocation_; }
      set { firePointLocation_ = value; }
    }

    private double minTurningRadius_;
    /// <summary>
    /// 最小转弯半径 
    /// </summary>
    public double MinTurningRadius {
      get { return minTurningRadius_; }
      set {
        minTurningRadius_ = value;
      }
    }

    private double maxTurningVelocity_;
    /// <summary>
    /// 最大转弯速度 
    /// </summary>
    public double MaxTurningVelocity {
      get { return maxTurningVelocity_; }
      set {
        maxTurningVelocity_ = value;
      }
    }

    private double maxClimbVelocity_;
    /// <summary>
    /// 最大爬升速度 
    /// </summary>
    public double MaxClimbVelocity {
      get { return maxClimbVelocity_; }
      set {
        maxClimbVelocity_ = value;
      }
    }

    private double maxDescentVelocity_;
    /// <summary>
    /// 最大下降速度 
    /// </summary>
    public double MaxDescentVelocity {
      get { return maxDescentVelocity_; }
      set {
        maxDescentVelocity_ = value;
      }
    }

    private double maxCruiseVelocity_;
    /// <summary>
    /// 最大巡航速度 
    /// </summary>
    public double MaxCruiseVelocity {
      get { return maxCruiseVelocity_; }
      set {
        maxCruiseVelocity_ = value;
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.ClimbSegment> _repeated_climbSegmentArr_codec
        = pb::FieldCodec.ForMessage(258, global::KYFramework.Network.ClimbSegment.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.ClimbSegment> climbSegmentArr_ = new pbc::RepeatedField<global::KYFramework.Network.ClimbSegment>();
    /// <summary>
    /// 爬升航段集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.ClimbSegment> ClimbSegmentArr {
      get { return climbSegmentArr_; }
      set { climbSegmentArr_ = value; }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.DescentSegment> _repeated_descentSegmentArr_codec
        = pb::FieldCodec.ForMessage(266, global::KYFramework.Network.DescentSegment.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.DescentSegment> descentSegmentArr_ = new pbc::RepeatedField<global::KYFramework.Network.DescentSegment>();
    /// <summary>
    /// 下降航段集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.DescentSegment> DescentSegmentArr {
      get { return descentSegmentArr_; }
      set { descentSegmentArr_ = value; }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.CruiseSegment> _repeated_cruiseSegmentArr_codec
        = pb::FieldCodec.ForMessage(274, global::KYFramework.Network.CruiseSegment.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.CruiseSegment> cruiseSegmentArr_ = new pbc::RepeatedField<global::KYFramework.Network.CruiseSegment>();
    /// <summary>
    /// 巡航航段集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.CruiseSegment> CruiseSegmentArr {
      get { return cruiseSegmentArr_; }
      set { cruiseSegmentArr_ = value; }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.TurningSegment> _repeated_turningSegmentArr_codec
        = pb::FieldCodec.ForMessage(282, global::KYFramework.Network.TurningSegment.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.TurningSegment> turningSegmentArr_ = new pbc::RepeatedField<global::KYFramework.Network.TurningSegment>();
    /// <summary>
    /// 转弯航段集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.TurningSegment> TurningSegmentArr {
      get { return turningSegmentArr_; }
      set { turningSegmentArr_ = value; }
    }

    private string aircraftID_ = "";
    /// <summary>
    /// 飞行器编号：按照“子任务-编队号-机号”方式命名” 
    /// </summary>
    public string AircraftID {
      get { return aircraftID_; }
      set {
        aircraftID_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (MissionName.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(MissionName);
      }
      if (MissionType.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(MissionType);
      }
      missionRectangle_.WriteTo(output, _repeated_missionRectangle_codec);
      if (MaxTakeoffWeight != 0D) {
        output.WriteRawTag(33);
        output.WriteDouble(MaxTakeoffWeight);
      }
      if (TakeoffEmptyWeight != 0D) {
        output.WriteRawTag(41);
        output.WriteDouble(TakeoffEmptyWeight);
      }
      if (MaxFlightRange != 0D) {
        output.WriteRawTag(49);
        output.WriteDouble(MaxFlightRange);
      }
      if (MaxFlightTime != 0D) {
        output.WriteRawTag(57);
        output.WriteDouble(MaxFlightTime);
      }
      if (ServiceCeiling != 0D) {
        output.WriteRawTag(65);
        output.WriteDouble(ServiceCeiling);
      }
      if (MaxFuelCapacity != 0D) {
        output.WriteRawTag(73);
        output.WriteDouble(MaxFuelCapacity);
      }
      if (MaxWeightCapacity != 0D) {
        output.WriteRawTag(81);
        output.WriteDouble(MaxWeightCapacity);
      }
      if (LoadName.Length != 0) {
        output.WriteRawTag(90);
        output.WriteString(LoadName);
      }
      if (LoadQuantity != 0) {
        output.WriteRawTag(96);
        output.WriteInt32(LoadQuantity);
      }
      if (LoadWeight != 0D) {
        output.WriteRawTag(105);
        output.WriteDouble(LoadWeight);
      }
      cityWeatherArr_.WriteTo(output, _repeated_cityWeatherArr_codec);
      baseArr_.WriteTo(output, _repeated_baseArr_codec);
      airRouteArr_.WriteTo(output, _repeated_airRouteArr_codec);
      if (EndSelection.Length != 0) {
        output.WriteRawTag(138, 1);
        output.WriteString(EndSelection);
      }
      terminusLocation_.WriteTo(output, _repeated_terminusLocation_codec);
      noFlyZoneCircleArr_.WriteTo(output, _repeated_noFlyZoneCircleArr_codec);
      noFlyZoneRectArr_.WriteTo(output, _repeated_noFlyZoneRectArr_codec);
      if (VisualDistance != 0D) {
        output.WriteRawTag(169, 1);
        output.WriteDouble(VisualDistance);
      }
      if (DetourDirection.Length != 0) {
        output.WriteRawTag(178, 1);
        output.WriteString(DetourDirection);
      }
      if (NumberOfDetour != 0) {
        output.WriteRawTag(184, 1);
        output.WriteInt32(NumberOfDetour);
      }
      if (DetourIntervalDistance != 0D) {
        output.WriteRawTag(193, 1);
        output.WriteDouble(DetourIntervalDistance);
      }
      if (DetourVelocity != 0D) {
        output.WriteRawTag(201, 1);
        output.WriteDouble(DetourVelocity);
      }
      firePointLocation_.WriteTo(output, _repeated_firePointLocation_codec);
      if (MinTurningRadius != 0D) {
        output.WriteRawTag(217, 1);
        output.WriteDouble(MinTurningRadius);
      }
      if (MaxTurningVelocity != 0D) {
        output.WriteRawTag(225, 1);
        output.WriteDouble(MaxTurningVelocity);
      }
      if (MaxClimbVelocity != 0D) {
        output.WriteRawTag(233, 1);
        output.WriteDouble(MaxClimbVelocity);
      }
      if (MaxDescentVelocity != 0D) {
        output.WriteRawTag(241, 1);
        output.WriteDouble(MaxDescentVelocity);
      }
      if (MaxCruiseVelocity != 0D) {
        output.WriteRawTag(249, 1);
        output.WriteDouble(MaxCruiseVelocity);
      }
      climbSegmentArr_.WriteTo(output, _repeated_climbSegmentArr_codec);
      descentSegmentArr_.WriteTo(output, _repeated_descentSegmentArr_codec);
      cruiseSegmentArr_.WriteTo(output, _repeated_cruiseSegmentArr_codec);
      turningSegmentArr_.WriteTo(output, _repeated_turningSegmentArr_codec);
      if (AircraftID.Length != 0) {
        output.WriteRawTag(162, 2);
        output.WriteString(AircraftID);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (MissionName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(MissionName);
      }
      if (MissionType.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(MissionType);
      }
      size += missionRectangle_.CalculateSize(_repeated_missionRectangle_codec);
      if (MaxTakeoffWeight != 0D) {
        size += 1 + 8;
      }
      if (TakeoffEmptyWeight != 0D) {
        size += 1 + 8;
      }
      if (MaxFlightRange != 0D) {
        size += 1 + 8;
      }
      if (MaxFlightTime != 0D) {
        size += 1 + 8;
      }
      if (ServiceCeiling != 0D) {
        size += 1 + 8;
      }
      if (MaxFuelCapacity != 0D) {
        size += 1 + 8;
      }
      if (MaxWeightCapacity != 0D) {
        size += 1 + 8;
      }
      if (LoadName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(LoadName);
      }
      if (LoadQuantity != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(LoadQuantity);
      }
      if (LoadWeight != 0D) {
        size += 1 + 8;
      }
      size += cityWeatherArr_.CalculateSize(_repeated_cityWeatherArr_codec);
      size += baseArr_.CalculateSize(_repeated_baseArr_codec);
      size += airRouteArr_.CalculateSize(_repeated_airRouteArr_codec);
      if (EndSelection.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(EndSelection);
      }
      size += terminusLocation_.CalculateSize(_repeated_terminusLocation_codec);
      size += noFlyZoneCircleArr_.CalculateSize(_repeated_noFlyZoneCircleArr_codec);
      size += noFlyZoneRectArr_.CalculateSize(_repeated_noFlyZoneRectArr_codec);
      if (VisualDistance != 0D) {
        size += 2 + 8;
      }
      if (DetourDirection.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(DetourDirection);
      }
      if (NumberOfDetour != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumberOfDetour);
      }
      if (DetourIntervalDistance != 0D) {
        size += 2 + 8;
      }
      if (DetourVelocity != 0D) {
        size += 2 + 8;
      }
      size += firePointLocation_.CalculateSize(_repeated_firePointLocation_codec);
      if (MinTurningRadius != 0D) {
        size += 2 + 8;
      }
      if (MaxTurningVelocity != 0D) {
        size += 2 + 8;
      }
      if (MaxClimbVelocity != 0D) {
        size += 2 + 8;
      }
      if (MaxDescentVelocity != 0D) {
        size += 2 + 8;
      }
      if (MaxCruiseVelocity != 0D) {
        size += 2 + 8;
      }
      size += climbSegmentArr_.CalculateSize(_repeated_climbSegmentArr_codec);
      size += descentSegmentArr_.CalculateSize(_repeated_descentSegmentArr_codec);
      size += cruiseSegmentArr_.CalculateSize(_repeated_cruiseSegmentArr_codec);
      size += turningSegmentArr_.CalculateSize(_repeated_turningSegmentArr_codec);
      if (AircraftID.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(AircraftID);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      missionName_ = "";
      missionType_ = "";
      for (int i = 0; i < missionRectangle_.Count; i++) { MessagePool.Instance.Recycle(missionRectangle_[i]); }
      missionRectangle_.Clear();
      loadName_ = "";
      loadQuantity_ = 0;
      for (int i = 0; i < cityWeatherArr_.Count; i++) { MessagePool.Instance.Recycle(cityWeatherArr_[i]); }
      cityWeatherArr_.Clear();
      for (int i = 0; i < baseArr_.Count; i++) { MessagePool.Instance.Recycle(baseArr_[i]); }
      baseArr_.Clear();
      for (int i = 0; i < airRouteArr_.Count; i++) { MessagePool.Instance.Recycle(airRouteArr_[i]); }
      airRouteArr_.Clear();
      endSelection_ = "";
      for (int i = 0; i < terminusLocation_.Count; i++) { MessagePool.Instance.Recycle(terminusLocation_[i]); }
      terminusLocation_.Clear();
      for (int i = 0; i < noFlyZoneCircleArr_.Count; i++) { MessagePool.Instance.Recycle(noFlyZoneCircleArr_[i]); }
      noFlyZoneCircleArr_.Clear();
      for (int i = 0; i < noFlyZoneRectArr_.Count; i++) { MessagePool.Instance.Recycle(noFlyZoneRectArr_[i]); }
      noFlyZoneRectArr_.Clear();
      detourDirection_ = "";
      numberOfDetour_ = 0;
      for (int i = 0; i < firePointLocation_.Count; i++) { MessagePool.Instance.Recycle(firePointLocation_[i]); }
      firePointLocation_.Clear();
      for (int i = 0; i < climbSegmentArr_.Count; i++) { MessagePool.Instance.Recycle(climbSegmentArr_[i]); }
      climbSegmentArr_.Clear();
      for (int i = 0; i < descentSegmentArr_.Count; i++) { MessagePool.Instance.Recycle(descentSegmentArr_[i]); }
      descentSegmentArr_.Clear();
      for (int i = 0; i < cruiseSegmentArr_.Count; i++) { MessagePool.Instance.Recycle(cruiseSegmentArr_[i]); }
      cruiseSegmentArr_.Clear();
      for (int i = 0; i < turningSegmentArr_.Count; i++) { MessagePool.Instance.Recycle(turningSegmentArr_[i]); }
      turningSegmentArr_.Clear();
      aircraftID_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            MissionName = input.ReadString();
            break;
          }
          case 18: {
            MissionType = input.ReadString();
            break;
          }
          case 26: {
            missionRectangle_.AddEntriesFrom(input, _repeated_missionRectangle_codec);
            break;
          }
          case 33: {
            MaxTakeoffWeight = input.ReadDouble();
            break;
          }
          case 41: {
            TakeoffEmptyWeight = input.ReadDouble();
            break;
          }
          case 49: {
            MaxFlightRange = input.ReadDouble();
            break;
          }
          case 57: {
            MaxFlightTime = input.ReadDouble();
            break;
          }
          case 65: {
            ServiceCeiling = input.ReadDouble();
            break;
          }
          case 73: {
            MaxFuelCapacity = input.ReadDouble();
            break;
          }
          case 81: {
            MaxWeightCapacity = input.ReadDouble();
            break;
          }
          case 90: {
            LoadName = input.ReadString();
            break;
          }
          case 96: {
            LoadQuantity = input.ReadInt32();
            break;
          }
          case 105: {
            LoadWeight = input.ReadDouble();
            break;
          }
          case 114: {
            cityWeatherArr_.AddEntriesFrom(input, _repeated_cityWeatherArr_codec);
            break;
          }
          case 122: {
            baseArr_.AddEntriesFrom(input, _repeated_baseArr_codec);
            break;
          }
          case 130: {
            airRouteArr_.AddEntriesFrom(input, _repeated_airRouteArr_codec);
            break;
          }
          case 138: {
            EndSelection = input.ReadString();
            break;
          }
          case 146: {
            terminusLocation_.AddEntriesFrom(input, _repeated_terminusLocation_codec);
            break;
          }
          case 154: {
            noFlyZoneCircleArr_.AddEntriesFrom(input, _repeated_noFlyZoneCircleArr_codec);
            break;
          }
          case 162: {
            noFlyZoneRectArr_.AddEntriesFrom(input, _repeated_noFlyZoneRectArr_codec);
            break;
          }
          case 169: {
            VisualDistance = input.ReadDouble();
            break;
          }
          case 178: {
            DetourDirection = input.ReadString();
            break;
          }
          case 184: {
            NumberOfDetour = input.ReadInt32();
            break;
          }
          case 193: {
            DetourIntervalDistance = input.ReadDouble();
            break;
          }
          case 201: {
            DetourVelocity = input.ReadDouble();
            break;
          }
          case 210: {
            firePointLocation_.AddEntriesFrom(input, _repeated_firePointLocation_codec);
            break;
          }
          case 217: {
            MinTurningRadius = input.ReadDouble();
            break;
          }
          case 225: {
            MaxTurningVelocity = input.ReadDouble();
            break;
          }
          case 233: {
            MaxClimbVelocity = input.ReadDouble();
            break;
          }
          case 241: {
            MaxDescentVelocity = input.ReadDouble();
            break;
          }
          case 249: {
            MaxCruiseVelocity = input.ReadDouble();
            break;
          }
          case 258: {
            climbSegmentArr_.AddEntriesFrom(input, _repeated_climbSegmentArr_codec);
            break;
          }
          case 266: {
            descentSegmentArr_.AddEntriesFrom(input, _repeated_descentSegmentArr_codec);
            break;
          }
          case 274: {
            cruiseSegmentArr_.AddEntriesFrom(input, _repeated_cruiseSegmentArr_codec);
            break;
          }
          case 282: {
            turningSegmentArr_.AddEntriesFrom(input, _repeated_turningSegmentArr_codec);
            break;
          }
          case 290: {
            AircraftID = input.ReadString();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 飞行计划编辑器（输出） 
  /// </summary>
  public partial class S2C_FlyPlanOutput : pb::IMessage {
    private static readonly pb::MessageParser<S2C_FlyPlanOutput> _parser = new pb::MessageParser<S2C_FlyPlanOutput>(() => (S2C_FlyPlanOutput)MessagePool.Instance.Fetch(typeof(S2C_FlyPlanOutput)));
    public static pb::MessageParser<S2C_FlyPlanOutput> Parser { get { return _parser; } }

    private string aircraftID_ = "";
    /// <summary>
    /// 飞行器编号 
    /// </summary>
    public string AircraftID {
      get { return aircraftID_; }
      set {
        aircraftID_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.PlanTurningPoint> _repeated_planTurningPointArr_codec
        = pb::FieldCodec.ForMessage(18, global::KYFramework.Network.PlanTurningPoint.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.PlanTurningPoint> planTurningPointArr_ = new pbc::RepeatedField<global::KYFramework.Network.PlanTurningPoint>();
    /// <summary>
    /// 飞行航路点集合 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.PlanTurningPoint> PlanTurningPointArr {
      get { return planTurningPointArr_; }
      set { planTurningPointArr_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (AircraftID.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(AircraftID);
      }
      planTurningPointArr_.WriteTo(output, _repeated_planTurningPointArr_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (AircraftID.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(AircraftID);
      }
      size += planTurningPointArr_.CalculateSize(_repeated_planTurningPointArr_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      aircraftID_ = "";
      for (int i = 0; i < planTurningPointArr_.Count; i++) { MessagePool.Instance.Recycle(planTurningPointArr_[i]); }
      planTurningPointArr_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            AircraftID = input.ReadString();
            break;
          }
          case 18: {
            planTurningPointArr_.AddEntriesFrom(input, _repeated_planTurningPointArr_codec);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 计划航路点 
  /// </summary>
  public partial class PlanTurningPoint : pb::IMessage {
    private static readonly pb::MessageParser<PlanTurningPoint> _parser = new pb::MessageParser<PlanTurningPoint>(() => (PlanTurningPoint)MessagePool.Instance.Fetch(typeof(PlanTurningPoint)));
    public static pb::MessageParser<PlanTurningPoint> Parser { get { return _parser; } }

    private string name_ = "";
    /// <summary>
    /// 名称：爬升、巡航、转弯、下降、观测火场 
    /// </summary>
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private global::KYFramework.Network.Point location_;
    /// <summary>
    /// 位置 
    /// </summary>
    public global::KYFramework.Network.Point Location {
      get { return location_; }
      set {
        location_ = value;
      }
    }

    private string type_ = "";
    /// <summary>
    /// 类型：普通、转弯、取水任务、灭火任务 
    /// </summary>
    public string Type {
      get { return type_; }
      set {
        type_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private double velocity_;
    /// <summary>
    /// 速度 
    /// </summary>
    public double Velocity {
      get { return velocity_; }
      set {
        velocity_ = value;
      }
    }

    private double segmentConsumption_;
    /// <summary>
    /// 航段油耗 
    /// </summary>
    public double SegmentConsumption {
      get { return segmentConsumption_; }
      set {
        segmentConsumption_ = value;
      }
    }

    private double segmentTime_;
    /// <summary>
    /// 航段飞行时间 
    /// </summary>
    public double SegmentTime {
      get { return segmentTime_; }
      set {
        segmentTime_ = value;
      }
    }

    private double radius_;
    /// <summary>
    /// 转弯半径 
    /// </summary>
    public double Radius {
      get { return radius_; }
      set {
        radius_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      if (location_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(Location);
      }
      if (Type.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(Type);
      }
      if (Velocity != 0D) {
        output.WriteRawTag(33);
        output.WriteDouble(Velocity);
      }
      if (SegmentConsumption != 0D) {
        output.WriteRawTag(41);
        output.WriteDouble(SegmentConsumption);
      }
      if (SegmentTime != 0D) {
        output.WriteRawTag(49);
        output.WriteDouble(SegmentTime);
      }
      if (Radius != 0D) {
        output.WriteRawTag(57);
        output.WriteDouble(Radius);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      if (location_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(Location);
      }
      if (Type.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Type);
      }
      if (Velocity != 0D) {
        size += 1 + 8;
      }
      if (SegmentConsumption != 0D) {
        size += 1 + 8;
      }
      if (SegmentTime != 0D) {
        size += 1 + 8;
      }
      if (Radius != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      name_ = "";
      if (location_ != null) MessagePool.Instance.Recycle(location_); location_ = null;
      type_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18: {
            if (location_ == null) {
              location_ = new global::KYFramework.Network.Point();
            }
            input.ReadMessage(location_);
            break;
          }
          case 26: {
            Type = input.ReadString();
            break;
          }
          case 33: {
            Velocity = input.ReadDouble();
            break;
          }
          case 41: {
            SegmentConsumption = input.ReadDouble();
            break;
          }
          case 49: {
            SegmentTime = input.ReadDouble();
            break;
          }
          case 57: {
            Radius = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 航路曲线（输出） 
  /// </summary>
  public partial class S2C_TurningPointOutput : pb::IMessage {
    private static readonly pb::MessageParser<S2C_TurningPointOutput> _parser = new pb::MessageParser<S2C_TurningPointOutput>(() => (S2C_TurningPointOutput)MessagePool.Instance.Fetch(typeof(S2C_TurningPointOutput)));
    public static pb::MessageParser<S2C_TurningPointOutput> Parser { get { return _parser; } }

    private string aircraftID_ = "";
    /// <summary>
    /// 飞行器编号 
    /// </summary>
    public string AircraftID {
      get { return aircraftID_; }
      set {
        aircraftID_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string turningPointName_ = "";
    /// <summary>
    /// 飞行航路点名称 
    /// </summary>
    public string TurningPointName {
      get { return turningPointName_; }
      set {
        turningPointName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.Point> _repeated_turningPointLocation_codec
        = pb::FieldCodec.ForMessage(26, global::KYFramework.Network.Point.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.Point> turningPointLocation_ = new pbc::RepeatedField<global::KYFramework.Network.Point>();
    /// <summary>
    /// 飞行航路点位置列表 
    /// </summary>
    public pbc::RepeatedField<global::KYFramework.Network.Point> TurningPointLocation {
      get { return turningPointLocation_; }
      set { turningPointLocation_ = value; }
    }

    private string presentMission_ = "";
    /// <summary>
    /// 当前任务阶段 
    /// </summary>
    public string PresentMission {
      get { return presentMission_; }
      set {
        presentMission_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string presentTarget_ = "";
    /// <summary>
    /// 当前飞行目标点 
    /// </summary>
    public string PresentTarget {
      get { return presentTarget_; }
      set {
        presentTarget_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string startDate_ = "";
    /// <summary>
    /// 航路开始日期 
    /// </summary>
    public string StartDate {
      get { return startDate_; }
      set {
        startDate_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string startTime_ = "";
    /// <summary>
    /// 航路开始时间 
    /// </summary>
    public string StartTime {
      get { return startTime_; }
      set {
        startTime_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string endDate_ = "";
    /// <summary>
    /// 航路结束日期 
    /// </summary>
    public string EndDate {
      get { return endDate_; }
      set {
        endDate_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string endTime_ = "";
    /// <summary>
    /// 航路结束时间 
    /// </summary>
    public string EndTime {
      get { return endTime_; }
      set {
        endTime_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private double elapsedTime_;
    /// <summary>
    /// 已飞行时间 
    /// </summary>
    public double ElapsedTime {
      get { return elapsedTime_; }
      set {
        elapsedTime_ = value;
      }
    }

    private string presentDate_ = "";
    /// <summary>
    /// 当前日期 
    /// </summary>
    public string PresentDate {
      get { return presentDate_; }
      set {
        presentDate_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string presentTime_ = "";
    /// <summary>
    /// 当前时刻 
    /// </summary>
    public string PresentTime {
      get { return presentTime_; }
      set {
        presentTime_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private global::KYFramework.Network.Point presentLocation_;
    /// <summary>
    /// 当前位置 
    /// </summary>
    public global::KYFramework.Network.Point PresentLocation {
      get { return presentLocation_; }
      set {
        presentLocation_ = value;
      }
    }

    private double presentFuelConsumption_;
    /// <summary>
    /// 当前已消耗油量 
    /// </summary>
    public double PresentFuelConsumption {
      get { return presentFuelConsumption_; }
      set {
        presentFuelConsumption_ = value;
      }
    }

    private double presentRemainingFuel_;
    /// <summary>
    /// 当前剩余油量 
    /// </summary>
    public double PresentRemainingFuel {
      get { return presentRemainingFuel_; }
      set {
        presentRemainingFuel_ = value;
      }
    }

    private double presentVelocity_;
    /// <summary>
    /// 当前飞行速度 
    /// </summary>
    public double PresentVelocity {
      get { return presentVelocity_; }
      set {
        presentVelocity_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (AircraftID.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(AircraftID);
      }
      if (TurningPointName.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(TurningPointName);
      }
      turningPointLocation_.WriteTo(output, _repeated_turningPointLocation_codec);
      if (PresentMission.Length != 0) {
        output.WriteRawTag(34);
        output.WriteString(PresentMission);
      }
      if (PresentTarget.Length != 0) {
        output.WriteRawTag(42);
        output.WriteString(PresentTarget);
      }
      if (StartDate.Length != 0) {
        output.WriteRawTag(50);
        output.WriteString(StartDate);
      }
      if (StartTime.Length != 0) {
        output.WriteRawTag(58);
        output.WriteString(StartTime);
      }
      if (EndDate.Length != 0) {
        output.WriteRawTag(66);
        output.WriteString(EndDate);
      }
      if (EndTime.Length != 0) {
        output.WriteRawTag(74);
        output.WriteString(EndTime);
      }
      if (ElapsedTime != 0D) {
        output.WriteRawTag(81);
        output.WriteDouble(ElapsedTime);
      }
      if (PresentDate.Length != 0) {
        output.WriteRawTag(90);
        output.WriteString(PresentDate);
      }
      if (PresentTime.Length != 0) {
        output.WriteRawTag(98);
        output.WriteString(PresentTime);
      }
      if (presentLocation_ != null) {
        output.WriteRawTag(106);
        output.WriteMessage(PresentLocation);
      }
      if (PresentFuelConsumption != 0D) {
        output.WriteRawTag(113);
        output.WriteDouble(PresentFuelConsumption);
      }
      if (PresentRemainingFuel != 0D) {
        output.WriteRawTag(121);
        output.WriteDouble(PresentRemainingFuel);
      }
      if (PresentVelocity != 0D) {
        output.WriteRawTag(129, 1);
        output.WriteDouble(PresentVelocity);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (AircraftID.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(AircraftID);
      }
      if (TurningPointName.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(TurningPointName);
      }
      size += turningPointLocation_.CalculateSize(_repeated_turningPointLocation_codec);
      if (PresentMission.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(PresentMission);
      }
      if (PresentTarget.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(PresentTarget);
      }
      if (StartDate.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(StartDate);
      }
      if (StartTime.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(StartTime);
      }
      if (EndDate.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(EndDate);
      }
      if (EndTime.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(EndTime);
      }
      if (ElapsedTime != 0D) {
        size += 1 + 8;
      }
      if (PresentDate.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(PresentDate);
      }
      if (PresentTime.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(PresentTime);
      }
      if (presentLocation_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(PresentLocation);
      }
      if (PresentFuelConsumption != 0D) {
        size += 1 + 8;
      }
      if (PresentRemainingFuel != 0D) {
        size += 1 + 8;
      }
      if (PresentVelocity != 0D) {
        size += 2 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      aircraftID_ = "";
      turningPointName_ = "";
      for (int i = 0; i < turningPointLocation_.Count; i++) { MessagePool.Instance.Recycle(turningPointLocation_[i]); }
      turningPointLocation_.Clear();
      presentMission_ = "";
      presentTarget_ = "";
      startDate_ = "";
      startTime_ = "";
      endDate_ = "";
      endTime_ = "";
      presentDate_ = "";
      presentTime_ = "";
      if (presentLocation_ != null) MessagePool.Instance.Recycle(presentLocation_); presentLocation_ = null;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            AircraftID = input.ReadString();
            break;
          }
          case 18: {
            TurningPointName = input.ReadString();
            break;
          }
          case 26: {
            turningPointLocation_.AddEntriesFrom(input, _repeated_turningPointLocation_codec);
            break;
          }
          case 34: {
            PresentMission = input.ReadString();
            break;
          }
          case 42: {
            PresentTarget = input.ReadString();
            break;
          }
          case 50: {
            StartDate = input.ReadString();
            break;
          }
          case 58: {
            StartTime = input.ReadString();
            break;
          }
          case 66: {
            EndDate = input.ReadString();
            break;
          }
          case 74: {
            EndTime = input.ReadString();
            break;
          }
          case 81: {
            ElapsedTime = input.ReadDouble();
            break;
          }
          case 90: {
            PresentDate = input.ReadString();
            break;
          }
          case 98: {
            PresentTime = input.ReadString();
            break;
          }
          case 106: {
            if (presentLocation_ == null) {
              presentLocation_ = new global::KYFramework.Network.Point();
            }
            input.ReadMessage(presentLocation_);
            break;
          }
          case 113: {
            PresentFuelConsumption = input.ReadDouble();
            break;
          }
          case 121: {
            PresentRemainingFuel = input.ReadDouble();
            break;
          }
          case 129: {
            PresentVelocity = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  public partial class C2S_GetReport : pb::IMessage {
    private static readonly pb::MessageParser<C2S_GetReport> _parser = new pb::MessageParser<C2S_GetReport>(() => (C2S_GetReport)MessagePool.Instance.Fetch(typeof(C2S_GetReport)));
    public static pb::MessageParser<C2S_GetReport> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(208, 5);
        output.WriteInt32(RpcId);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 720: {
            RpcId = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  public partial class S2C_GetReport : pb::IMessage {
    private static readonly pb::MessageParser<S2C_GetReport> _parser = new pb::MessageParser<S2C_GetReport>(() => (S2C_GetReport)MessagePool.Instance.Fetch(typeof(S2C_GetReport)));
    public static pb::MessageParser<S2C_GetReport> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    private int error_;
    public int Error {
      get { return error_; }
      set {
        error_ = value;
      }
    }

    private string message_ = "";
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.ResportWithTaskName> _repeated_reports_codec
        = pb::FieldCodec.ForMessage(746, global::KYFramework.Network.ResportWithTaskName.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.ResportWithTaskName> reports_ = new pbc::RepeatedField<global::KYFramework.Network.ResportWithTaskName>();
    public pbc::RepeatedField<global::KYFramework.Network.ResportWithTaskName> Reports {
      get { return reports_; }
      set { reports_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(208, 5);
        output.WriteInt32(RpcId);
      }
      if (Error != 0) {
        output.WriteRawTag(216, 5);
        output.WriteInt32(Error);
      }
      if (Message.Length != 0) {
        output.WriteRawTag(226, 5);
        output.WriteString(Message);
      }
      reports_.WriteTo(output, _repeated_reports_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      if (Error != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(Error);
      }
      if (Message.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      size += reports_.CalculateSize(_repeated_reports_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      error_ = 0;
      message_ = "";
      for (int i = 0; i < reports_.Count; i++) { MessagePool.Instance.Recycle(reports_[i]); }
      reports_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 720: {
            RpcId = input.ReadInt32();
            break;
          }
          case 728: {
            Error = input.ReadInt32();
            break;
          }
          case 738: {
            Message = input.ReadString();
            break;
          }
          case 746: {
            reports_.AddEntriesFrom(input, _repeated_reports_codec);
            break;
          }
        }
      }
    }

  }

  public partial class ResportWithTaskName : pb::IMessage {
    private static readonly pb::MessageParser<ResportWithTaskName> _parser = new pb::MessageParser<ResportWithTaskName>(() => (ResportWithTaskName)MessagePool.Instance.Fetch(typeof(ResportWithTaskName)));
    public static pb::MessageParser<ResportWithTaskName> Parser { get { return _parser; } }

    private int firePointId_;
    public int FirePointId {
      get { return firePointId_; }
      set {
        firePointId_ = value;
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.EntitySheetReportValue> _repeated_entitySheetReportValueArr_codec
        = pb::FieldCodec.ForMessage(18, global::KYFramework.Network.EntitySheetReportValue.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.EntitySheetReportValue> entitySheetReportValueArr_ = new pbc::RepeatedField<global::KYFramework.Network.EntitySheetReportValue>();
    public pbc::RepeatedField<global::KYFramework.Network.EntitySheetReportValue> EntitySheetReportValueArr {
      get { return entitySheetReportValueArr_; }
      set { entitySheetReportValueArr_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (FirePointId != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(FirePointId);
      }
      entitySheetReportValueArr_.WriteTo(output, _repeated_entitySheetReportValueArr_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (FirePointId != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(FirePointId);
      }
      size += entitySheetReportValueArr_.CalculateSize(_repeated_entitySheetReportValueArr_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      firePointId_ = 0;
      for (int i = 0; i < entitySheetReportValueArr_.Count; i++) { MessagePool.Instance.Recycle(entitySheetReportValueArr_[i]); }
      entitySheetReportValueArr_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            FirePointId = input.ReadInt32();
            break;
          }
          case 18: {
            entitySheetReportValueArr_.AddEntriesFrom(input, _repeated_entitySheetReportValueArr_codec);
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 仿真开始 
  /// </summary>
  public partial class C2S_StmulationStart : pb::IMessage {
    private static readonly pb::MessageParser<C2S_StmulationStart> _parser = new pb::MessageParser<C2S_StmulationStart>(() => (C2S_StmulationStart)MessagePool.Instance.Fetch(typeof(C2S_StmulationStart)));
    public static pb::MessageParser<C2S_StmulationStart> Parser { get { return _parser; } }

    public void WriteTo(pb::CodedOutputStream output) {
    }

    public int CalculateSize() {
      int size = 0;
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
        }
      }
    }

  }

  /// <summary>
  /// 仿真倍速调整 
  /// </summary>
  public partial class C2S_StmulationTimeScale : pb::IMessage {
    private static readonly pb::MessageParser<C2S_StmulationTimeScale> _parser = new pb::MessageParser<C2S_StmulationTimeScale>(() => (C2S_StmulationTimeScale)MessagePool.Instance.Fetch(typeof(C2S_StmulationTimeScale)));
    public static pb::MessageParser<C2S_StmulationTimeScale> Parser { get { return _parser; } }

    private int timeScale_;
    public int TimeScale {
      get { return timeScale_; }
      set {
        timeScale_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (TimeScale != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(TimeScale);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (TimeScale != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(TimeScale);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      timeScale_ = 0;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            TimeScale = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 仿真结束 
  /// </summary>
  public partial class S2C_StmulationEnd : pb::IMessage {
    private static readonly pb::MessageParser<S2C_StmulationEnd> _parser = new pb::MessageParser<S2C_StmulationEnd>(() => (S2C_StmulationEnd)MessagePool.Instance.Fetch(typeof(S2C_StmulationEnd)));
    public static pb::MessageParser<S2C_StmulationEnd> Parser { get { return _parser; } }

    private int firePointId_;
    public int FirePointId {
      get { return firePointId_; }
      set {
        firePointId_ = value;
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.EntitySheetReportValue> _repeated_entitySheetReportValueArr_codec
        = pb::FieldCodec.ForMessage(18, global::KYFramework.Network.EntitySheetReportValue.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.EntitySheetReportValue> entitySheetReportValueArr_ = new pbc::RepeatedField<global::KYFramework.Network.EntitySheetReportValue>();
    public pbc::RepeatedField<global::KYFramework.Network.EntitySheetReportValue> EntitySheetReportValueArr {
      get { return entitySheetReportValueArr_; }
      set { entitySheetReportValueArr_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (FirePointId != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(FirePointId);
      }
      entitySheetReportValueArr_.WriteTo(output, _repeated_entitySheetReportValueArr_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (FirePointId != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(FirePointId);
      }
      size += entitySheetReportValueArr_.CalculateSize(_repeated_entitySheetReportValueArr_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      firePointId_ = 0;
      for (int i = 0; i < entitySheetReportValueArr_.Count; i++) { MessagePool.Instance.Recycle(entitySheetReportValueArr_[i]); }
      entitySheetReportValueArr_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            FirePointId = input.ReadInt32();
            break;
          }
          case 18: {
            entitySheetReportValueArr_.AddEntriesFrom(input, _repeated_entitySheetReportValueArr_codec);
            break;
          }
        }
      }
    }

  }

  public partial class EntitySheetReportValue : pb::IMessage {
    private static readonly pb::MessageParser<EntitySheetReportValue> _parser = new pb::MessageParser<EntitySheetReportValue>(() => (EntitySheetReportValue)MessagePool.Instance.Fetch(typeof(EntitySheetReportValue)));
    public static pb::MessageParser<EntitySheetReportValue> Parser { get { return _parser; } }

    private string name_ = "";
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.SheetReportValue> _repeated_sheetReportValueArr_codec
        = pb::FieldCodec.ForMessage(18, global::KYFramework.Network.SheetReportValue.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.SheetReportValue> sheetReportValueArr_ = new pbc::RepeatedField<global::KYFramework.Network.SheetReportValue>();
    public pbc::RepeatedField<global::KYFramework.Network.SheetReportValue> SheetReportValueArr {
      get { return sheetReportValueArr_; }
      set { sheetReportValueArr_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      sheetReportValueArr_.WriteTo(output, _repeated_sheetReportValueArr_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      size += sheetReportValueArr_.CalculateSize(_repeated_sheetReportValueArr_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      name_ = "";
      for (int i = 0; i < sheetReportValueArr_.Count; i++) { MessagePool.Instance.Recycle(sheetReportValueArr_[i]); }
      sheetReportValueArr_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18: {
            sheetReportValueArr_.AddEntriesFrom(input, _repeated_sheetReportValueArr_codec);
            break;
          }
        }
      }
    }

  }

  public partial class SheetReportValue : pb::IMessage {
    private static readonly pb::MessageParser<SheetReportValue> _parser = new pb::MessageParser<SheetReportValue>(() => (SheetReportValue)MessagePool.Instance.Fetch(typeof(SheetReportValue)));
    public static pb::MessageParser<SheetReportValue> Parser { get { return _parser; } }

    private string name_ = "";
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private static readonly pb::FieldCodec<global::KYFramework.Network.ReportValue> _repeated_valueArr_codec
        = pb::FieldCodec.ForMessage(18, global::KYFramework.Network.ReportValue.Parser);
    private pbc::RepeatedField<global::KYFramework.Network.ReportValue> valueArr_ = new pbc::RepeatedField<global::KYFramework.Network.ReportValue>();
    public pbc::RepeatedField<global::KYFramework.Network.ReportValue> ValueArr {
      get { return valueArr_; }
      set { valueArr_ = value; }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      valueArr_.WriteTo(output, _repeated_valueArr_codec);
    }

    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      size += valueArr_.CalculateSize(_repeated_valueArr_codec);
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      name_ = "";
      for (int i = 0; i < valueArr_.Count; i++) { MessagePool.Instance.Recycle(valueArr_[i]); }
      valueArr_.Clear();
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18: {
            valueArr_.AddEntriesFrom(input, _repeated_valueArr_codec);
            break;
          }
        }
      }
    }

  }

  public partial class ReportValue : pb::IMessage {
    private static readonly pb::MessageParser<ReportValue> _parser = new pb::MessageParser<ReportValue>(() => (ReportValue)MessagePool.Instance.Fetch(typeof(ReportValue)));
    public static pb::MessageParser<ReportValue> Parser { get { return _parser; } }

    private string name_ = "";
    public string Name {
      get { return name_; }
      set {
        name_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string value_ = "";
    public string Value {
      get { return value_; }
      set {
        value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (Name.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(Name);
      }
      if (Value.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(Value);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (Name.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Name);
      }
      if (Value.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Value);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      name_ = "";
      value_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            Name = input.ReadString();
            break;
          }
          case 18: {
            Value = input.ReadString();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 请求 效能评估 
  /// </summary>
  public partial class C2S_SimulationResult : pb::IMessage {
    private static readonly pb::MessageParser<C2S_SimulationResult> _parser = new pb::MessageParser<C2S_SimulationResult>(() => (C2S_SimulationResult)MessagePool.Instance.Fetch(typeof(C2S_SimulationResult)));
    public static pb::MessageParser<C2S_SimulationResult> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(208, 5);
        output.WriteInt32(RpcId);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 720: {
            RpcId = input.ReadInt32();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 返回 效能评估 
  /// </summary>
  public partial class S2C_SimulatinResult : pb::IMessage {
    private static readonly pb::MessageParser<S2C_SimulatinResult> _parser = new pb::MessageParser<S2C_SimulatinResult>(() => (S2C_SimulatinResult)MessagePool.Instance.Fetch(typeof(S2C_SimulatinResult)));
    public static pb::MessageParser<S2C_SimulatinResult> Parser { get { return _parser; } }

    private int rpcId_;
    public int RpcId {
      get { return rpcId_; }
      set {
        rpcId_ = value;
      }
    }

    private int error_;
    public int Error {
      get { return error_; }
      set {
        error_ = value;
      }
    }

    private string message_ = "";
    public string Message {
      get { return message_; }
      set {
        message_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private double taskResponseTime_;
    /// <summary>
    /// 任务响应时间(秒) 
    /// </summary>
    public double TaskResponseTime {
      get { return taskResponseTime_; }
      set {
        taskResponseTime_ = value;
      }
    }

    private double taskTotalTime_;
    /// <summary>
    /// 总任务耗时(秒) 
    /// </summary>
    public double TaskTotalTime {
      get { return taskTotalTime_; }
      set {
        taskTotalTime_ = value;
      }
    }

    private double singleJoinTime_;
    /// <summary>
    /// 单机入场时间(秒) 
    /// </summary>
    public double SingleJoinTime {
      get { return singleJoinTime_; }
      set {
        singleJoinTime_ = value;
      }
    }

    private double singleEffectiveTaskTime_;
    /// <summary>
    /// 单机有效任务时长(秒) 
    /// </summary>
    public double SingleEffectiveTaskTime {
      get { return singleEffectiveTaskTime_; }
      set {
        singleEffectiveTaskTime_ = value;
      }
    }

    private double singleAllPeopeo_;
    /// <summary>
    /// 单机总投送人数(人) 
    /// </summary>
    public double SingleAllPeopeo {
      get { return singleAllPeopeo_; }
      set {
        singleAllPeopeo_ = value;
      }
    }

    private double singleEachPeople_;
    /// <summary>
    /// 单机单次投送人数(人) 
    /// </summary>
    public double SingleEachPeople {
      get { return singleEachPeople_; }
      set {
        singleEachPeople_ = value;
      }
    }

    private double speedPatrol_;
    /// <summary>
    /// 巡护速度(km/h) 
    /// </summary>
    public double SpeedPatrol {
      get { return speedPatrol_; }
      set {
        speedPatrol_ = value;
      }
    }

    private double voyagePatrol_;
    /// <summary>
    /// 巡护航程 (km)
    /// </summary>
    public double VoyagePatrol {
      get { return voyagePatrol_; }
      set {
        voyagePatrol_ = value;
      }
    }

    private double timeAllPatrol_;
    /// <summary>
    /// 总巡护耗时 (秒)
    /// </summary>
    public double TimeAllPatrol {
      get { return timeAllPatrol_; }
      set {
        timeAllPatrol_ = value;
      }
    }

    private double fireJoinTime_;
    /// <summary>
    /// 火情入场时间 (秒)
    /// </summary>
    public double FireJoinTime {
      get { return fireJoinTime_; }
      set {
        fireJoinTime_ = value;
      }
    }

    private double fuelSingle_;
    /// <summary>
    /// 单机总油耗 (kg)
    /// </summary>
    public double FuelSingle {
      get { return fuelSingle_; }
      set {
        fuelSingle_ = value;
      }
    }

    private string airportUseSituation_ = "";
    /// <summary>
    /// 单机机场使用情况 
    /// </summary>
    public string AirportUseSituation {
      get { return airportUseSituation_; }
      set {
        airportUseSituation_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string navUseSituation_ = "";
    /// <summary>
    /// 单机导航使用情况 
    /// </summary>
    public string NavUseSituation {
      get { return navUseSituation_; }
      set {
        navUseSituation_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private double fireJoinTimeEconomical_;
    /// <summary>
    /// 单机总任务时长(秒) 
    /// </summary>
    public double FireJoinTimeEconomical {
      get { return fireJoinTimeEconomical_; }
      set {
        fireJoinTimeEconomical_ = value;
      }
    }

    private double fuelSingleEconomical_;
    /// <summary>
    /// 单机总油耗(kg) 
    /// </summary>
    public double FuelSingleEconomical {
      get { return fuelSingleEconomical_; }
      set {
        fuelSingleEconomical_ = value;
      }
    }

    private string airportUseSituationEconomical_ = "";
    /// <summary>
    /// 单机机场使用情况 
    /// </summary>
    public string AirportUseSituationEconomical {
      get { return airportUseSituationEconomical_; }
      set {
        airportUseSituationEconomical_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private string navUseSituationEconomical_ = "";
    /// <summary>
    /// 单机导航使用情况 
    /// </summary>
    public string NavUseSituationEconomical {
      get { return navUseSituationEconomical_; }
      set {
        navUseSituationEconomical_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (RpcId != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(RpcId);
      }
      if (Error != 0) {
        output.WriteRawTag(16);
        output.WriteInt32(Error);
      }
      if (Message.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(Message);
      }
      if (TaskResponseTime != 0D) {
        output.WriteRawTag(33);
        output.WriteDouble(TaskResponseTime);
      }
      if (TaskTotalTime != 0D) {
        output.WriteRawTag(41);
        output.WriteDouble(TaskTotalTime);
      }
      if (SingleJoinTime != 0D) {
        output.WriteRawTag(49);
        output.WriteDouble(SingleJoinTime);
      }
      if (SingleEffectiveTaskTime != 0D) {
        output.WriteRawTag(57);
        output.WriteDouble(SingleEffectiveTaskTime);
      }
      if (SingleAllPeopeo != 0D) {
        output.WriteRawTag(65);
        output.WriteDouble(SingleAllPeopeo);
      }
      if (SingleEachPeople != 0D) {
        output.WriteRawTag(73);
        output.WriteDouble(SingleEachPeople);
      }
      if (SpeedPatrol != 0D) {
        output.WriteRawTag(81);
        output.WriteDouble(SpeedPatrol);
      }
      if (VoyagePatrol != 0D) {
        output.WriteRawTag(89);
        output.WriteDouble(VoyagePatrol);
      }
      if (TimeAllPatrol != 0D) {
        output.WriteRawTag(97);
        output.WriteDouble(TimeAllPatrol);
      }
      if (FireJoinTime != 0D) {
        output.WriteRawTag(105);
        output.WriteDouble(FireJoinTime);
      }
      if (FuelSingle != 0D) {
        output.WriteRawTag(113);
        output.WriteDouble(FuelSingle);
      }
      if (AirportUseSituation.Length != 0) {
        output.WriteRawTag(122);
        output.WriteString(AirportUseSituation);
      }
      if (NavUseSituation.Length != 0) {
        output.WriteRawTag(130, 1);
        output.WriteString(NavUseSituation);
      }
      if (FireJoinTimeEconomical != 0D) {
        output.WriteRawTag(137, 1);
        output.WriteDouble(FireJoinTimeEconomical);
      }
      if (FuelSingleEconomical != 0D) {
        output.WriteRawTag(145, 1);
        output.WriteDouble(FuelSingleEconomical);
      }
      if (AirportUseSituationEconomical.Length != 0) {
        output.WriteRawTag(154, 1);
        output.WriteString(AirportUseSituationEconomical);
      }
      if (NavUseSituationEconomical.Length != 0) {
        output.WriteRawTag(162, 1);
        output.WriteString(NavUseSituationEconomical);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (RpcId != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(RpcId);
      }
      if (Error != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Error);
      }
      if (Message.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(Message);
      }
      if (TaskResponseTime != 0D) {
        size += 1 + 8;
      }
      if (TaskTotalTime != 0D) {
        size += 1 + 8;
      }
      if (SingleJoinTime != 0D) {
        size += 1 + 8;
      }
      if (SingleEffectiveTaskTime != 0D) {
        size += 1 + 8;
      }
      if (SingleAllPeopeo != 0D) {
        size += 1 + 8;
      }
      if (SingleEachPeople != 0D) {
        size += 1 + 8;
      }
      if (SpeedPatrol != 0D) {
        size += 1 + 8;
      }
      if (VoyagePatrol != 0D) {
        size += 1 + 8;
      }
      if (TimeAllPatrol != 0D) {
        size += 1 + 8;
      }
      if (FireJoinTime != 0D) {
        size += 1 + 8;
      }
      if (FuelSingle != 0D) {
        size += 1 + 8;
      }
      if (AirportUseSituation.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(AirportUseSituation);
      }
      if (NavUseSituation.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(NavUseSituation);
      }
      if (FireJoinTimeEconomical != 0D) {
        size += 2 + 8;
      }
      if (FuelSingleEconomical != 0D) {
        size += 2 + 8;
      }
      if (AirportUseSituationEconomical.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(AirportUseSituationEconomical);
      }
      if (NavUseSituationEconomical.Length != 0) {
        size += 2 + pb::CodedOutputStream.ComputeStringSize(NavUseSituationEconomical);
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      rpcId_ = 0;
      error_ = 0;
      message_ = "";
      airportUseSituation_ = "";
      navUseSituation_ = "";
      airportUseSituationEconomical_ = "";
      navUseSituationEconomical_ = "";
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            RpcId = input.ReadInt32();
            break;
          }
          case 16: {
            Error = input.ReadInt32();
            break;
          }
          case 26: {
            Message = input.ReadString();
            break;
          }
          case 33: {
            TaskResponseTime = input.ReadDouble();
            break;
          }
          case 41: {
            TaskTotalTime = input.ReadDouble();
            break;
          }
          case 49: {
            SingleJoinTime = input.ReadDouble();
            break;
          }
          case 57: {
            SingleEffectiveTaskTime = input.ReadDouble();
            break;
          }
          case 65: {
            SingleAllPeopeo = input.ReadDouble();
            break;
          }
          case 73: {
            SingleEachPeople = input.ReadDouble();
            break;
          }
          case 81: {
            SpeedPatrol = input.ReadDouble();
            break;
          }
          case 89: {
            VoyagePatrol = input.ReadDouble();
            break;
          }
          case 97: {
            TimeAllPatrol = input.ReadDouble();
            break;
          }
          case 105: {
            FireJoinTime = input.ReadDouble();
            break;
          }
          case 113: {
            FuelSingle = input.ReadDouble();
            break;
          }
          case 122: {
            AirportUseSituation = input.ReadString();
            break;
          }
          case 130: {
            NavUseSituation = input.ReadString();
            break;
          }
          case 137: {
            FireJoinTimeEconomical = input.ReadDouble();
            break;
          }
          case 145: {
            FuelSingleEconomical = input.ReadDouble();
            break;
          }
          case 154: {
            AirportUseSituationEconomical = input.ReadString();
            break;
          }
          case 162: {
            NavUseSituationEconomical = input.ReadString();
            break;
          }
        }
      }
    }

  }

  /// <summary>
  /// 火焰蔓延输出 
  /// </summary>
  public partial class S2C_FireSpread : pb::IMessage {
    private static readonly pb::MessageParser<S2C_FireSpread> _parser = new pb::MessageParser<S2C_FireSpread>(() => (S2C_FireSpread)MessagePool.Instance.Fetch(typeof(S2C_FireSpread)));
    public static pb::MessageParser<S2C_FireSpread> Parser { get { return _parser; } }

    private string aircraftId_ = "";
    public string AircraftId {
      get { return aircraftId_; }
      set {
        aircraftId_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    private int firePointId_;
    public int FirePointId {
      get { return firePointId_; }
      set {
        firePointId_ = value;
      }
    }

    private double fireGrids_;
    public double FireGrids {
      get { return fireGrids_; }
      set {
        fireGrids_ = value;
      }
    }

    private double firedGrids_;
    public double FiredGrids {
      get { return firedGrids_; }
      set {
        firedGrids_ = value;
      }
    }

    public void WriteTo(pb::CodedOutputStream output) {
      if (AircraftId.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(AircraftId);
      }
      if (FirePointId != 0) {
        output.WriteRawTag(16);
        output.WriteInt32(FirePointId);
      }
      if (FireGrids != 0D) {
        output.WriteRawTag(25);
        output.WriteDouble(FireGrids);
      }
      if (FiredGrids != 0D) {
        output.WriteRawTag(33);
        output.WriteDouble(FiredGrids);
      }
    }

    public int CalculateSize() {
      int size = 0;
      if (AircraftId.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(AircraftId);
      }
      if (FirePointId != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(FirePointId);
      }
      if (FireGrids != 0D) {
        size += 1 + 8;
      }
      if (FiredGrids != 0D) {
        size += 1 + 8;
      }
      return size;
    }

    public void MergeFrom(pb::CodedInputStream input) {
      aircraftId_ = "";
      firePointId_ = 0;
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            AircraftId = input.ReadString();
            break;
          }
          case 16: {
            FirePointId = input.ReadInt32();
            break;
          }
          case 25: {
            FireGrids = input.ReadDouble();
            break;
          }
          case 33: {
            FiredGrids = input.ReadDouble();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code