/// <summary>
/// Initializes a new instance of the <see cref="IModelo2D"/> class.
/// </summary>
/// <param name="ModelType">Type of the model.</param>
public IModelo2D(ModelType ModelType)
{
this.ModelType = ModelType;
LayerDepth = 0;
SourceRectangle = null;
Rotation = 0;
}
public static void GenConvertToModel(StringBuilder builder, ModelType Model)
{
string ModelName = Model.Name.Value;
builder.AppendLine(GeneratorUtil.TabString(1) + @"public static " + ModelName + " " + GetConvertName(Model.Name.Value) + "(DataRow row )");
builder.AppendLine(GeneratorUtil.TabString(1) + "{");
builder.AppendLine(GeneratorUtil.TabString(2) + ModelName + " info = new " + ModelName + "();");
foreach (FieldType field in Model.MyFields)
{
string systemType = field.SystemType.Value;
string fieldName = field.Name.Value;
string columnName = field.ColumnName.Value;
builder.AppendLine(GeneratorUtil.TabString(2) + "if ( row[\"" + columnName + "\"] == DBNull.Value)");
builder.AppendLine(GeneratorUtil.TabString(2) + "{");
if (!field.NullAble.Value)
{
builder.AppendLine(GeneratorUtil.TabString(3) + "info." + fieldName + " = default(" + systemType + ");");
}
builder.AppendLine(GeneratorUtil.TabString(2) + "}");
builder.AppendLine(GeneratorUtil.TabString(2) + "else");
builder.AppendLine(GeneratorUtil.TabString(2) + "{");
builder.AppendLine(GeneratorUtil.TabString(3) + "info." + fieldName + " = (" + systemType + ")row[\"" + columnName + "\"];");
builder.AppendLine(GeneratorUtil.TabString(2) + "}");
}
builder.AppendLine(GeneratorUtil.TabString(2) + "return info;");
builder.AppendLine(GeneratorUtil.TabString(1) + "}");
}
public MyModel(Project1Game game, VertexPositionColor[] shapeArray, String textureName)
{
this.vertices = Buffer.Vertex.New(game.GraphicsDevice, shapeArray);
this.inputLayout = VertexInputLayout.New<VertexPositionColor>(0);
vertexStride = Utilities.SizeOf<VertexPositionColor>();
modelType = ModelType.Colored;
}
public HandRepresentation(int handID, Hand hand, Chirality chirality, ModelType modelType) {
HandID = handID;
this.MostRecentHand = hand;
this.RepChirality = chirality;
this.RepType = modelType;
}
public NewDbContextTemplateModel(string dbContextName, ModelType modelType)
{
if (dbContextName == null)
{
throw new ArgumentNullException(nameof(dbContextName));
}
if (modelType == null)
{
throw new ArgumentNullException(nameof(modelType));
}
var modelNamespace = modelType.Namespace;
ModelTypeName = modelType.Name;
RequiredNamespaces = new HashSet<string>();
var classNameModel = new ClassNameModel(dbContextName);
DbContextTypeName = classNameModel.ClassName;
DbContextNamespace = classNameModel.NamespaceName;
if (!string.IsNullOrEmpty(modelNamespace) &&
!string.Equals(modelNamespace, DbContextNamespace, StringComparison.Ordinal))
{
RequiredNamespaces.Add(modelNamespace);
}
}
internal JsonInstance(ModelType type, string id)
{
this.Type = type;
this.Id = id;
this.instance = new ModelInstance(this);
instanceProperties = new object[Type.Properties.Count];
}
public static bool IsASupportedModelType(ModelType modelType)
{
switch(modelType)
{
case ModelType.Truss1D:
return false;
case ModelType.Beam1D:
return true;
case ModelType.Truss2D:
return false;
case ModelType.Frame2D:
return true;
case ModelType.Slab2D:
return true;
case ModelType.Membrane2D:
return false;
case ModelType.Truss3D:
return false;
case ModelType.Membrane3D:
return false;
case ModelType.MultiStorey2DSlab:
return true;
case ModelType.Full3D:
return true;
default:
throw new NotImplementedException(string.Format(
System.Globalization.CultureInfo.InvariantCulture,
"Linear3DBeam.IsSupportedModelType(ModelType) has not been defined for a model type of {0}",
modelType));
}
}
private async void LoadData(Uri location, ModelType modelType = ModelType.Line)
{
if (HttpClient != null)
{
_httpClient.BaseAddress = location;
var response = await _httpClient.GetAsync(_httpClient.BaseAddress);
response.EnsureSuccessStatusCode();
var jsonResult = response.Content.ReadAsStringAsync().Result;
var resultArray = JsonConvert.DeserializeObject(jsonResult);
var result = resultArray as JArray;
switch (modelType)
{
case ModelType.Line:
foreach (JObject jsonObj in result)
{
Line line = JsonConvert.DeserializeObject<Line>(jsonObj.ToString());
Lines.Add(line);
}
break;
case ModelType.Stop:
foreach (var jsonObj in result)
{
var stop = JsonConvert.DeserializeObject<Stop>(jsonObj.ToString());
Stops.Add(stop);
}
break;
default:
break;
}
}
}
public override HandRepresentation MakeHandRepresentation(Leap.Hand hand, ModelType modelType)
{
HandRepresentation handRep = null;
for (int i = 0; i < ModelPool.Count; i++) {
IHandModel model = ModelPool[i];
bool isCorrectHandedness;
if(model.Handedness == Chirality.Either) {
isCorrectHandedness = true;
} else {
Chirality handChirality = hand.IsRight ? Chirality.Right : Chirality.Left;
isCorrectHandedness = model.Handedness == handChirality;
}
bool isCorrectModelType;
isCorrectModelType = model.HandModelType == modelType;
if(isCorrectHandedness && isCorrectModelType) {
ModelPool.RemoveAt(i);
handRep = new HandProxy(this, model, hand);
break;
}
}
return handRep;
}
private void SaveResearchInfo(Guid researchID,
string researchName,
ResearchType rType,
ModelType mType,
int realizationCount)
{
throw new NotImplementedException();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="dsElementName"></param>
/// <param name="dataType"></param>
/// <param name="alias"></param>
/// <param name="allowsNull"></param>
public DisplaySetServiceArgumentInfo(string name, string dsElementName, ModelType dataType, string alias, bool allowsNull)
{
mName = name;
mDSElementName = dsElementName;
mDataType = dataType;
mAlias = alias;
mAllowsNull = allowsNull;
}
protected ModelMethodParameter(ModelMethod method, string name, Type parameterType, ModelType referenceType, bool isList)
{
this.Method = method;
this.Name = name;
this.ParameterType = parameterType;
this.ReferenceType = referenceType;
this.IsList = isList;
}
public MyModel(LabGame game, VertexPositionColor[] shapeArray, String textureName, float collisionRadius)
{
this.vertices = Buffer.Vertex.New(game.GraphicsDevice, shapeArray);
this.inputLayout = VertexInputLayout.New<VertexPositionColor>(0);
vertexStride = Utilities.SizeOf<VertexPositionColor>();
modelType = ModelType.Colored;
this.collisionRadius = collisionRadius;
}
public HandProxy(HandPool parent, Hand hand, Chirality repChirality, ModelType repType) :
base(hand.Id, hand, repChirality, repType)
{
this.parent = parent;
this.RepChirality = repChirality;
this.RepType = repType;
this.MostRecentHand = hand;
}
/// <summary>
/// Constructor
/// </summary>
public ModelInfo(string projectId, string modelId, List<Guid> elementIds, ModelType modelType)
{
ProjectId = projectId;
ModelId = modelId;
ElementIds = elementIds;
ModelType = modelType;
_controller = DataController.Instance;
}
/// <summary>
/// Apply display format by default for all data types
/// All the values will be shown using those formats
/// </summary>
/// <param name="value">Value.</param>
/// <param name="dataType">Data type.</param>
/// <returns>string.</returns>
public static string ApplyDisplayFormat(object value, ModelType dataType)
{
if (value == null)
{
return string.Empty;
}
try
{
string format = GetDefaultDisplayMask(dataType);
switch (dataType)
{
case ModelType.Date:
DateTime DateAux = System.Convert.ToDateTime(value, CultureManager.Culture);
return DateAux.ToString(format);
case ModelType.DateTime:
DateTime DateTimeAux = System.Convert.ToDateTime(value, CultureManager.Culture);
return DateTimeAux.ToString(format);
case ModelType.Time:
DateTime TimeAux = System.Convert.ToDateTime(value.ToString(), CultureManager.Culture);
return TimeAux.ToString(format);
case ModelType.Autonumeric:
case ModelType.Int:
int IntAux = System.Convert.ToInt32(value);
return IntAux.ToString(format);
case ModelType.Nat:
UInt32 NatAux = System.Convert.ToUInt32(value);
return NatAux.ToString(format);
case ModelType.Real:
Decimal RealAux = System.Convert.ToDecimal(value);
return RealAux.ToString(format);
case ModelType.String:
case ModelType.Password:
case ModelType.Blob:
case ModelType.Text:
string StringAux = System.Convert.ToString(value);
return StringAux.ToString(CultureManager.Culture);
case ModelType.Bool:
bool BoolAux = System.Convert.ToBoolean(value);
return BoolAux.ToString(CultureManager.Culture);
default:
return value.ToString();
}
}
catch
{
return value.ToString();
}
}
public GH_Model(ModelType modelType)
{
this.ModelType = modelType;
this.Model = new FiniteElementModel(ModelType);
this.Nodes = new List<FiniteElementNode>();
this.Points = new List<Point3d>();
this.Results = null;
this.Elements = new List<GH_Element>();
this.Loads = new List<GH_Load>();
this.Supports = new List<GH_Support>();
}
/// <summary>
/// Creates a new <see cref="ModelSource"/> for the specified root type and path.
/// </summary>
/// <param name="rootType">The root type name, which is required for instance paths</param>
/// <param name="path">The source path, which is either an instance path or a static path</param>
public ModelSource(ModelType rootType, string path)
{
// Raise an error if the specified path is not valid
if (!pathValidation.IsMatch(path))
throw new ArgumentException("The specified path, '" + path + "', was not valid path syntax.");
// Raise an error if the specified path is not valid
ModelProperty property;
if (!InitializeFromTypeAndPath(rootType, path, out property))
throw new ArgumentException("The specified path, '" + path + "', was not valid for the root type of '" + rootType.Name + "'.", "path");
}
/// <summary>
/// Retrieves available analyze options for specified research type and model type.
/// </summary>
/// <param name="rt">Research type.</param>
/// <param name="mt">Model type.</param>
/// <returns>Available analyze options.</returns>
/// <note>Analyze option is available for research, if it is available
/// both for research type and model type.</note>
public static AnalyzeOption GetAvailableAnalyzeOptions(ResearchType rt, ModelType mt)
{
ResearchTypeInfo[] rInfo = (ResearchTypeInfo[])rt.GetType().GetField(rt.ToString()).GetCustomAttributes(typeof(ResearchTypeInfo), false);
Type researchType = Type.GetType(rInfo[0].Implementation, true);
AvailableAnalyzeOption rAvailableOptions = ((AvailableAnalyzeOption[])researchType.GetCustomAttributes(typeof(AvailableAnalyzeOption), true))[0];
ModelTypeInfo[] mInfo = (ModelTypeInfo[])mt.GetType().GetField(mt.ToString()).GetCustomAttributes(typeof(ModelTypeInfo), false);
Type modelType = Type.GetType(mInfo[0].Implementation, true);
AvailableAnalyzeOption mAvailableOptions = ((AvailableAnalyzeOption[])modelType.GetCustomAttributes(typeof(AvailableAnalyzeOption), true))[0];
return rAvailableOptions.Options & mAvailableOptions.Options;
}
public ModelTypeInfo GetModelTypeInfo(ModelType type)
{
// Create the set of type instance information if not initialized
if (Instances == null)
Instances = new Dictionary<string, ModelTypeInfo>();
// Get or initialize the model type instance information store
ModelTypeInfo typeInfo;
if (!Instances.TryGetValue(type.Name, out typeInfo))
Instances[type.Name] = typeInfo = new ModelTypeInfo();
// Return the requested value
return typeInfo;
}
/// <summary>
/// Creates a new instance of the 'IntroductionPattern' class for numeric values (Int or Nat).
/// </summary>
/// <param name="dataType">Data type of the introduction pattern.</param>
/// <param name="minValue">Minimum value of the introduction pattern.</param>
/// <param name="maxValue">Maximum value of the introduction pattern.</param>
/// <param name="maxIntegerDigits">Maximum integer digits of the introduction pattern.</param>
/// <param name="ipValidationMessage">Validation message of the introduction pattern.</param>
public IntroductionPattern(
ModelType dataType,
decimal? minValue,
decimal? maxValue,
string ipValidationMessage)
{
DataType = dataType;
MinValue = minValue;
MaxValue = maxValue;
if (minValue == null || maxValue == null)
{
// If one of the two limits is not specified, it can not be restricted the max number of digits.
mMaxIntegerDigits = null;
}
else
{
// Calculate the maximum number of integer positions, based on the max value and the min value.
int? lMaxIntegerDigitsFromMaxValue = null;
int? lMaxIntegerDigitsFromMinValue = null;
if (maxValue != null)
{
lMaxIntegerDigitsFromMaxValue = 1;
if (maxValue.Value != 0)
{
maxValue = Math.Abs(maxValue.Value); // Get the unsigned value, because Log10 returns NaN for negative values.
double lMaxValue = Math.Truncate(Math.Abs(Math.Log10((double)maxValue.Value))) + 1;
lMaxIntegerDigitsFromMaxValue = Convert.ToInt32(lMaxValue);
}
}
if (minValue != null)
{
lMaxIntegerDigitsFromMinValue = 1;
if (minValue.Value != 0)
{
minValue = Math.Abs(minValue.Value); // Get the unsigned value, because Log10 returns NaN for negative values.
double lMinValue = Math.Truncate(Math.Abs(Math.Log10((double)minValue.Value))) + 1;
lMaxIntegerDigitsFromMinValue = Convert.ToInt32(lMinValue);
}
}
if (lMaxIntegerDigitsFromMaxValue != null && lMaxIntegerDigitsFromMinValue != null)
{
// Get the maximum value between the max number of digits for maxValue and the max number of digits for minValue.
mMaxIntegerDigits = Math.Max(lMaxIntegerDigitsFromMaxValue.Value, lMaxIntegerDigitsFromMinValue.Value);
}
}
IPValidationMessage = ipValidationMessage;
}
/// <summary>
/// Get a scene or create it (And add it in the scene list)
/// </summary>
/// <param name="idAnimation"></param>
/// <returns></returns>
protected KineapScene GetOrCreateScene(int idAnimation, ModelType modelType)
{
KineapScene matchingSkeleton = sceneList.Where(animTmp => animTmp.SceneId == idAnimation)
.FirstOrDefault();
Scene matchingScene = null;
if (matchingSkeleton == null)
{
matchingScene = new Scene();
matchingSkeleton = new KineapScene(idAnimation, matchingScene);
matchingSkeleton.ModelType = modelType;
this.sceneList.Add(matchingSkeleton);
}
else
matchingScene = matchingSkeleton.Scene;
return matchingSkeleton;
}
protected internal ModelValueProperty(ModelType declaringType, string name, string label, string helptext, string format, bool isStatic, Type propertyType, TypeConverter converter, bool isList = false, bool isReadOnly = false, bool isPersisted = true, Attribute[] attributes = null, LambdaExpression defaultValue = null)
: base(declaringType, name, label, helptext, format, isStatic, isList, isReadOnly, isPersisted, attributes)
{
this.PropertyType = propertyType;
this.Converter = converter;
this.AutoConvert = converter != null && converter.CanConvertTo(typeof(object));
this.FormatProvider = declaringType.GetFormatProvider(propertyType);
if (defaultValue != null)
{
if (defaultValue.Parameters.Count > 0)
throw new ArgumentException("Default value expressions cannot have parameters.");
if (propertyType.IsAssignableFrom(defaultValue.Type))
throw new ArgumentException("Default value expressions must match the type of the property they are for.");
this.DefaultValue = defaultValue;
}
}
/// <summary>
/// Instanciranje novog modela prema tipu modela.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Model NewModelInstance(ModelType type)
{
if (type == ModelType.Users)
return new UsersModel();
else if (type == ModelType.ClassesInSchools)
return new ClassesInSchoolsModel();
else if (type == ModelType.Courses)
return new CoursesModel();
else if (type == ModelType.CourseRubrics)
return new CourseRubricsModel();
else if (type == ModelType.Grades)
return new GradesModel();
else if(type == ModelType.Classes)
return new ClassesModel();
return null;
}
public JsonModel JsonToObject(string json, ModelType type)
{
switch (type)
{
case ModelType.Current:
return JsonConvert.DeserializeObject<CurrentJsonModel>(json);
case ModelType.Forecast5Days:
return JsonConvert.DeserializeObject<Forecast5DaysJsonModel>(json);
case ModelType.Forecast16Days:
return JsonConvert.DeserializeObject<Forecast16DaysJsonModel>(json);
default:
return null;
}
}
/**
* MakeHandRepresentation receives a Hand and combines that with an IHandModel to create a HandRepresentation
* @param hand The Leap Hand data to be drive an IHandModel
* @param modelType Filters for a type of hand model, for example, physics or graphics hands.
*/
public override HandRepresentation MakeHandRepresentation(Hand hand, ModelType modelType)
{
Chirality handChirality = hand.IsRight ? Chirality.Right : Chirality.Left;
HandRepresentation handRep = new HandProxy(this, hand, handChirality, modelType);
for (int i = 0; i < ModelPool.Count; i++) {
ModelGroup group = ModelPool[i];
if (group.IsEnabled) {
IHandModel model = group.TryGetModel(handChirality, modelType);
if (model != null) {
handRep.AddModel(model);
modelToHandRepMapping.Add(model, handRep);
}
}
}
activeHandReps.Add(handRep);
return handRep;
}
internal static POSModel TrainPOSModel(ModelType type = ModelType.Maxent) {
var p = new TrainingParameters();
switch (type) {
case ModelType.Maxent:
p.Set(Parameters.Algorithm, "MAXENT");
break;
case ModelType.Perceptron:
p.Set(Parameters.Algorithm, "PERCEPTRON");
break;
default:
throw new NotSupportedException();
}
p.Set(Parameters.Iterations, "100");
p.Set(Parameters.Cutoff, "5");
return POSTaggerME.Train("en", CreateSampleStream(), p, new POSTaggerFactory());
}
/// <summary>
/// Initializes a new instance of the 'ArgumentDVController' class.
/// </summary>
/// <param name="name">Name of the data-valued Argument.</param>
/// <param name="alias">Alias of the data-valued Argument.</param>
/// <param name="idXML">IdXML of the data-valued Argument.</param>
/// <param name="modelType">ModelType of the data-valued Argument.</param>
/// <param name="nullAllowed">Indicates whether the data-valued Argument allows null values.</param>
/// <param name="options">List of options of the defined selection.</param>
/// <param name="optionsDefaultValue">Default selected option for the defined seelction.</param>
/// <param name="parent">Parent controller.</param>
public ArgumentDVController(
string name,
string alias,
string idXML,
ModelType modelType,
bool nullAllowed,
List<KeyValuePair<object, string>> options,
object optionsDefaultValue,
IUController parent)
: base(name, parent, alias, idXML, nullAllowed, false)
{
mModelType = modelType;
mOptions = options;
// Add the 'null' value to the options list.
if (nullAllowed)
{
mOptions.Insert(0, new KeyValuePair<object, string>(null, string.Empty));
}
mOptionsDefaultValue = optionsDefaultValue;
}
public void GivenTheCurrentSceneContainsAModelResourceListWithAMeshResourceNamed(ModelType type, string modelName)
{
IDTFScene currentScene = ScenarioContext.Current.Get<IDTFScene>();
ModelResource m1 = null;
switch (type)
{
case ModelType.MESH:
m1 = new ModelResource(ModelType.MESH);
break;
case ModelType.LINE_SET:
m1 = new ModelResource(ModelType.LINE_SET);
break;
}
m1.Name = modelName;
currentScene.ModelResources.Add(modelName, m1);
ScenarioContext.Current.Set<ModelResource>(m1, modelName);
}
public XmlModel XmlToObject(StreamReader str, ModelType type)
{
switch (type)
{
case ModelType.Current:
serializer = new XmlSerializer(typeof(CurrentXmlModel));
return (CurrentXmlModel)serializer.Deserialize(str);
case ModelType.Forecast5Days:
serializer = new XmlSerializer(typeof(Forecast5DaysXmlModel));
return (Forecast5DaysXmlModel)serializer.Deserialize(str);
case ModelType.Forecast16Days:
serializer = new XmlSerializer(typeof(Forecast16DaysXmlModel));
return (Forecast16DaysXmlModel)serializer.Deserialize(str);
default:
return null;
}
}
private string processQueryString()
{
string retval = "";
_sCaseName = "";
if (Request.QueryString["CaseName"] != null)
{
_sCaseName = Request.QueryString["CaseName"];
}
if (_sCaseName == "")
{
retval = "ERROR: CaseName cannot be null\r\n";
}
Random randomGen = new Random();
DateTime dNow = DateTime.Now;
//string sNow = dNow.Year.ToString() + dNow.Month.ToString() + dNow.Day.ToString() + dNow.Hour.ToString() + dNow.Minute.ToString() + dNow.Second.ToString() + dNow.Millisecond.ToString();
string sNow = dNow.Millisecond.ToString();
_FileName = _sCaseName + "_" + sNow + "_" + randomGen.Next(10000, 99999);
string sModelType = "";
if (Request.QueryString["ModelType"] != null)
{
sModelType = Request.QueryString["ModelType"];
}
switch (sModelType.ToUpper())
{
case "OILSPILL":
_eModelType = ModelType.OilModel;
break;
case "CHEMSPILL":
_eModelType = ModelType.ChemModel;
break;
default:
retval += "ERROR: Unrecognized Model Type: " + sModelType + "\r\n";
break;
}
string[] sDateFormats = new string[] { "yyyyMMddTHH:mm:ss", "yyyyMMddTHH:mm",
"MM/dd/yyyyTHH:mm:ss", "MM/dd/yyyyTHH:mm",
"dd/MM/yyyyTHH:mm:ss", "dd/MM/yyyyTHH:mm" };
if (Request.QueryString["StartDate"] != null)
{
if (!(DateTime.TryParseExact(Request.QueryString["StartDate"], sDateFormats, new CultureInfo("en-US"), System.Globalization.DateTimeStyles.None, out _StartDate)))
{
retval += "ERROR: StartDate is invalid: " + Request.QueryString["StartDate"] + "\r\n";
retval += "Needs to be in one of the following formats:\r\n" + sDateFormats[0] + "r\n" +
sDateFormats[1] + "\r\n" +
sDateFormats[2] + "\r\n" +
sDateFormats[3] + "\r\n" +
sDateFormats[4] + "\r\n" +
sDateFormats[5] + "\r\n";
}
}
else
{
retval += "ERROR: Start Date is missing.\r\n";
}
_SpillAmount = 0;
if (Request.QueryString["Volume"] != null)
{
_SpillAmount = int.Parse(Request.QueryString["Volume"]);
}
_OilUnits = 4; //default to Tonnes
if (Request.QueryString["OilUnits"] != null)
{
_OilUnits = int.Parse(Request.QueryString["OilUnits"]);
}
_Duration = 0;
if (Request.QueryString["Duration"] != null)
{
_Duration = int.Parse(Request.QueryString["Duration"]);
}
_SimLength = 24; //default to one day
if (Request.QueryString["SimLength"] != null)
{
_SimLength = int.Parse(Request.QueryString["SimLength"]);
}
_EndDate = _StartDate.AddHours(_SimLength);
_sLocation = "";
if (Request.QueryString["Location"] != null)
{
_sLocation = Request.QueryString["Location"];
}
double lat = 0;
if (Request.QueryString["IncLat"] != null)
{
lat = Convert.ToDouble(Request.QueryString["IncLat"]);
}
double lon = 0;
if (Request.QueryString["IncLon"] != null)
{
lon = Convert.ToDouble(Request.QueryString["IncLon"]);
}
_IncidentSite = new LatLon(lat, lon);
_AOI = CalculateAOI(_IncidentSite, _Duration); // new BoundingBox(Request.QueryString["BBox"]);
_Winds = -999; //default to no winds
if (Request.QueryString["Winds"] != null)
{
_Winds = int.Parse(Request.QueryString["Winds"]);
}
_Currents = -999; //default to no currents
if (Request.QueryString["Currents"] != null)
{
_Currents = int.Parse(Request.QueryString["Currents"]);
}
_EcopWinds = "";
if (Request.QueryString["EcopWinds"] != null)
{
_EcopWinds = Request.QueryString["EcopWinds"];
}
_EcopCurrents = "";
if (Request.QueryString["EcopCurrents"] != null)
{
_EcopCurrents = Request.QueryString["EcopCurrents"];
}
_WindMag = 0;
if (Request.QueryString["WindMag"] != null)
{
_WindMag = int.Parse(Request.QueryString["WindMag"]);
}
_WindDir = 0;
if (Request.QueryString["WindDir"] != null)
{
string myDir = Request.QueryString["WindDir"];
_WindDir = GetDirectionFromString(myDir) + 180; //to get into direction from
if (_WindDir > 360)
{
_WindDir -= 360;
}
}
_CurrMag = 0;
if (Request.QueryString["CurrMag"] != null)
{
_CurrMag = int.Parse(Request.QueryString["CurrMag"]);
}
_groupIDShare = "62f6db44ba6d42a7b66334db5f0f0fe2";
if (Request.QueryString["group"] != null)
{
_groupIDShare = Request.QueryString["group"];
}
_scriptID = "Model2Shape";
if (Request.QueryString["scriptid"] != null)
{
_scriptID = Request.QueryString["scriptid"];
}
_ShareEveryone = "false";
if (Request.QueryString["every1share"] != null)
{
_ShareEveryone = Request.QueryString["every1share"];
}
_CurrDir = 0;
if (Request.QueryString["CurrDir"] != null)
{
string myDir = Request.QueryString["CurrDir"];
_CurrDir = GetDirectionFromString(myDir);
}
_OilType = "Diesel"; //default to Diesel
if (Request.QueryString["OilType"] != null)
{
_OilType = Request.QueryString["OilType"];
}
//_ChemType = "Benzene"; //default to benzene
//if (Request.QueryString["ChemID"] != null)
// _ChemType = Request.QueryString["ChemID"];
//_bIsRivers = false;
//if (Request.QueryString["River"] != null)
// _bIsRivers = Convert.ToBoolean(Request.QueryString["River"]);
_ModelMethod = true; //default to Fast method
if (Request.QueryString["Speed"] != null)
{
_ModelMethod = (Request.QueryString["Speed"].ToUpper() == "FAST");
}
string sWaterTemp = "15C";
if (Request.QueryString["WaterTemp"] != null)
{
sWaterTemp = Request.QueryString["WaterTemp"];
}
_WaterTemp = double.Parse(sWaterTemp.Substring(0, sWaterTemp.Length - 1));
if (sWaterTemp.Substring(sWaterTemp.Length - 1, 1) == "F")
{
_WaterTemp = (_WaterTemp - 32) * (5 / 9);
}
_ClientKey = "";
if (Request.QueryString["ClientKey"] != null)
{
_ClientKey = Request.QueryString["ClientKey"];
}
return(retval);
}
public void GenerateSimpleType_Ambiguous_Issue()
{
// Umbraco returns nice, pascal-cased names.
var type1 = new TypeModel
{
Id = 1,
Alias = "type1",
ClrName = "Type1",
ParentId = 0,
BaseType = null,
ItemType = TypeModel.ItemTypes.Content,
};
type1.Properties.Add(new PropertyModel
{
Alias = "foo",
ClrName = "Foo",
ModelClrType = typeof(IEnumerable <>).MakeGenericType(ModelType.For("foo")),
});
var type2 = new TypeModel
{
Id = 2,
Alias = "foo",
ClrName = "Foo",
ParentId = 0,
BaseType = null,
ItemType = TypeModel.ItemTypes.Element,
};
TypeModel[] types = new[] { type1, type2 };
var modelsBuilderConfig = new ModelsBuilderSettings();
var builder = new TextBuilder(modelsBuilderConfig, types)
{
ModelsNamespace = "Umbraco.Cms.Web.Common.PublishedModels"
};
var sb1 = new StringBuilder();
builder.Generate(sb1, builder.GetModelsToGenerate().Skip(1).First());
var gen1 = sb1.ToString();
Console.WriteLine(gen1);
var sb = new StringBuilder();
builder.Generate(sb, builder.GetModelsToGenerate().First());
var gen = sb.ToString();
SemVersion version = ApiVersion.Current.Version;
var expected = @"//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Umbraco.ModelsBuilder.Embedded v" + version + @"
//
// Changes to this file will be lost if the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Linq.Expressions;
using Umbraco.Cms.Core.Models.PublishedContent;
using Umbraco.Cms.Core.PublishedCache;
using Umbraco.Cms.Infrastructure.ModelsBuilder;
using Umbraco.Cms.Core;
using Umbraco.Extensions;
namespace Umbraco.Cms.Web.Common.PublishedModels
{
[PublishedModel(""type1"")]
public partial class Type1 : PublishedContentModel
{
// helpers
#pragma warning disable 0109 // new is redundant
[global::System.CodeDom.Compiler.GeneratedCodeAttribute(""Umbraco.ModelsBuilder.Embedded"", """ + version + @""")]
public new const string ModelTypeAlias = ""type1"";
[global::System.CodeDom.Compiler.GeneratedCodeAttribute(""Umbraco.ModelsBuilder.Embedded"", """ + version + @""")]
public new const PublishedItemType ModelItemType = PublishedItemType.Content;
[global::System.CodeDom.Compiler.GeneratedCodeAttribute(""Umbraco.ModelsBuilder.Embedded"", """ + version + @""")]
[return: global::System.Diagnostics.CodeAnalysis.MaybeNull]
public new static IPublishedContentType GetModelContentType(IPublishedSnapshotAccessor publishedSnapshotAccessor)
=> PublishedModelUtility.GetModelContentType(publishedSnapshotAccessor, ModelItemType, ModelTypeAlias);
[global::System.CodeDom.Compiler.GeneratedCodeAttribute(""Umbraco.ModelsBuilder.Embedded"", """ + version + @""")]
[return: global::System.Diagnostics.CodeAnalysis.MaybeNull]
public static IPublishedPropertyType GetModelPropertyType<TValue>(IPublishedSnapshotAccessor publishedSnapshotAccessor, Expression<Func<Type1, TValue>> selector)
=> PublishedModelUtility.GetModelPropertyType(GetModelContentType(publishedSnapshotAccessor), selector);
#pragma warning restore 0109
private IPublishedValueFallback _publishedValueFallback;
// ctor
public Type1(IPublishedContent content, IPublishedValueFallback publishedValueFallback)
: base(content, publishedValueFallback)
{
_publishedValueFallback = publishedValueFallback;
}
// properties
[global::System.CodeDom.Compiler.GeneratedCodeAttribute(""Umbraco.ModelsBuilder.Embedded"", """ + version + @""")]
[global::System.Diagnostics.CodeAnalysis.MaybeNull]
[ImplementPropertyType(""foo"")]
public virtual global::System.Collections.Generic.IEnumerable<global::" + modelsBuilderConfig.ModelsNamespace + @".Foo> Foo => this.Value<global::System.Collections.Generic.IEnumerable<global::" + modelsBuilderConfig.ModelsNamespace + @".Foo>>(_publishedValueFallback, ""foo"");
}
}
";
Console.WriteLine(gen);
Assert.AreEqual(expected.ClearLf(), gen);
}
//清除匹配的model列表
public bool ClearAllMatchModels()
{
bool needFill = false;
for (int y = 0; y < yRow; y++)
{
for (int x = 0; x < xCol; x++)
{
if (models[x, y].CanClear())
{
List <ModelBase> matchList = MatchModels(models[x, y], x, y);
if (matchList != null)
{
int num = matchList.Count;
//根据消除个数处理分数
if (gameBegin)
{
switch (num)
{
case 3:
scoreStep = 20;
score += scoreStep;
ScoreAddEffect(0);
break;
case 4:
Excellent(0);
scoreStep = 60;
score += scoreStep;
ScoreAddEffect(1);
break;
case 5:
scoreStep = 80;
score += scoreStep;
if (isSkill == false)
{
gameTime += 6f;
curLevelTime += 6;
Excellent(1);
PlayerPrefs.SetInt("TimeAddNums", PlayerPrefs.GetInt("TimeAddNums", 0) + 6); //记录累计加时
}
ScoreAddEffect(2);
break;
case 6:
matchSixTimes++;
scoreStep = 180;
score += scoreStep;
if (isSkill == false)
{
gameTime += 10;
curLevelTime += 10;
Excellent(2);
PlayerPrefs.SetInt("TimeAddNums", PlayerPrefs.GetInt("TimeAddNums", 0) + 10); //记录累计加时
}
ScoreAddEffect(3);
break;
case 7:
scoreStep = 310;
score += scoreStep;
if (isSkill == false)
{
curLevelTime += 15;
gameTime += 15;
Excellent(3);
PlayerPrefs.SetInt("TimeAddNums", PlayerPrefs.GetInt("TimeAddNums", 0) + 15); //记录累计加时
}
PlayerPrefs.SetInt("Diamand", PlayerPrefs.GetInt("Diamand", 0) + award);
diamandText.text = award + "";
ScoreAddEffect(4);
showTaskFinishedPanel = true;
break;
}
//生成奖励球
ModelType specialModelType = ModelType.Count;//是否产生特殊奖励
ModelBase model = matchList[UnityEngine.Random.Range(0, matchList.Count)];
//ModelBase model = models[UnityEngine.Random.Range(0, xCol), UnityEngine.Random.Range(0, yRow)];
int specialModelX = model.X;
int specialModelY = model.Y;
if (matchList.Count == 5)
{
specialModelType = ModelType.CrossClear;
}
else if (matchList.Count >= 6 && !isSkill)
{
specialModelType = ModelType.RainBow;
Debug.Log("rainbow " + matchList.Count);
}
if (isSkill)
{
specialModelType = ModelType.Count;
}
matchList.Add(models[model.x, model.y]);
foreach (var m in matchList)
{
if (ClearModel(m.X, m.Y))
{
needFill = true;
}
}
if (specialModelType != ModelType.Count)
{
isSkill = true;
}
if (specialModelType != ModelType.Count && gameBegin)
{
if (models[specialModelX, specialModelY].type == ModelType.Empty)
{
Destroy(models[specialModelX, specialModelY]);
ModelBase newModel = CreatNewModel(specialModelX, specialModelY, specialModelType);
if (specialModelType == ModelType.CrossClear && newModel.CanColor() && matchList[0].CanColor())
{
newModel.ModelColorComponent.SetColor(ModelColor.ColorType.Cross);
}
//Rainbow
else if (specialModelType == ModelType.RainBow && newModel.CanColor())
{
newModel.ModelColorComponent.SetColor(ModelColor.ColorType.Rainbow);
}
}
}
}
}
}
}
}
return(needFill);
}
/**
* Updates HandRepresentations based in the specified HandRepresentation Dictionary.
* Active HandRepresentation instances are updated if the hand they represent is still
* present in the Provider's CurrentFrame; otherwise, the HandRepresentation is removed. If new
* Leap Hand objects are present in the Leap HandRepresentation Dictionary, new HandRepresentations are
* created and added to the dictionary.
* @param all_hand_reps = A dictionary of Leap Hand ID's with a paired HandRepresentation
* @param modelType Filters for a type of hand model, for example, physics or graphics hands.
* @param frame The Leap Frame containing Leap Hand data for each currently tracked hand
*/
void UpdateHandRepresentations(Dictionary <int, HandRepresentation> all_hand_reps, ModelType modelType, Frame frame)
{
foreach (Leap.Hand curHand in frame.Hands)
{
HandRepresentation rep;
if (!all_hand_reps.TryGetValue(curHand.Id, out rep))
{
rep = Factory.MakeHandRepresentation(curHand, modelType);
if (rep != null)
{
all_hand_reps.Add(curHand.Id, rep);
}
}
if (rep != null)
{
rep.IsMarked = true;
rep.UpdateRepresentation(curHand, modelType);
rep.LastUpdatedTime = (int)frame.Timestamp;
}
}
/** Mark-and-sweep to finish unused HandRepresentations */
HandRepresentation toBeDeleted = null;
foreach (KeyValuePair <int, HandRepresentation> r in all_hand_reps)
{
if (r.Value != null)
{
if (r.Value.IsMarked)
{
r.Value.IsMarked = false;
}
else
{
/** Initialize toBeDeleted with a value to be deleted */
//Debug.Log("Finishing");
toBeDeleted = r.Value;
}
}
}
/**Inform the representation that we will no longer be giving it any hand updates
* because the corresponding hand has gone away */
if (toBeDeleted != null)
{
all_hand_reps.Remove(toBeDeleted.HandID);
toBeDeleted.Finish();
}
}
/// <summary>
/// Creates a model data
/// </summary>
/// <param name="name">Name of model</param>
/// <param name="modelName">Internal name of model</param>
/// <param name="type">Type of model</param>
public ModelData(string name, string modelName, ModelType type)
{
Name = name;
ModelName = modelName;
Type = type;
}
public asteroidInfo(ModelType modelname, CollisionSphere[] spheres)
{
this.model = modelname;
this.collisionSpheres = spheres;
}
protected static List <IPrediction> DeserializePredictions(ModelType modelType,
dynamic jsonObject)
{
var propertyValues = (JObject)jsonObject.data;
var data = new List <IPrediction>();
if (propertyValues.Count > 0)
{
string typeName = modelType.Prediction.Name;
switch (typeName)
{
case "Color":
{
foreach (dynamic color in jsonObject.data.colors)
{
data.Add(Color.Deserialize(color));
}
break;
}
case "Concept":
{
foreach (dynamic concept in jsonObject.data.concepts)
{
data.Add(Concept.Deserialize(concept));
}
break;
}
case "Demographics":
{
foreach (dynamic demographics in jsonObject.data.regions)
{
data.Add(Demographics.Deserialize(demographics));
}
break;
}
case "Embedding":
{
foreach (dynamic embedding in jsonObject.data.embeddings)
{
data.Add(Embedding.Deserialize(embedding));
}
break;
}
case "FaceConcepts":
{
foreach (dynamic faceConcepts in
jsonObject.data.regions)
{
data.Add(FaceConcepts.Deserialize(faceConcepts));
}
break;
}
case "FaceDetection":
{
foreach (dynamic faceDetection in jsonObject.data.regions)
{
data.Add(FaceDetection.Deserialize(faceDetection));
}
break;
}
case "FaceEmbedding":
{
foreach (dynamic faceEmbedding in jsonObject.data.regions)
{
data.Add(FaceEmbedding.Deserialize(faceEmbedding));
}
break;
}
case "Focus":
{
foreach (dynamic focus in jsonObject.data.regions)
{
data.Add(Focus.Deserialize(focus,
(decimal)jsonObject.data.focus.value));
}
break;
}
case "Frame":
{
foreach (dynamic frame in jsonObject.data.frames)
{
data.Add(Frame.Deserialize(frame));
}
break;
}
case "Logo":
{
foreach (dynamic logo in jsonObject.data.regions)
{
data.Add(Logo.Deserialize(logo));
}
break;
}
default:
{
throw new ClarifaiException(
string.Format("Unknown output type `{0}`", typeName));
}
}
}
return(data);
}
public ActionResult Dosomething(ModelType model)
{
//your code
return(View());
}
public void Compile(string fileNameBase, string fileNameDefinition, string fileNameOutput)
{
if (_OutputListener == null)
{
_OutputListener = new ConsoleOutputListener();
}
XmlSerializer serializer = new XmlSerializer(typeof(ModelType));
StreamReader streamBase = new StreamReader(fileNameBase);
StreamReader streamDef = new StreamReader(fileNameDefinition);
using (streamBase)
{
var modelBM = (ModelType)serializer.Deserialize(streamBase);
FMTreeNode root = MAXTreeNodeUtils.ToTree(modelBM, treeNodes);
baseName = root.baseModelObject.name;
using (streamDef)
{
ModelType modelCI = (ModelType)serializer.Deserialize(streamDef);
var objectsCI = new Dictionary <string, ObjectType>();
foreach (ObjectType maxObj in modelCI.objects)
{
objectsCI[maxObj.id] = maxObj;
}
/**
* Bind compiler instructions to the related base element nodes
* and add new nodes.
*
* TODO: Child nodes may come before (new) parent is added. Figure out how to fix this.
*/
foreach (RelationshipType rel in modelCI.relationships)
{
/**
* Check if destination is inside Profile Definition.
* E.g. for internal relationships in Profile Definition or for new elements.
* Then create empty PLACEHOLDER, cleaned up afterwards.
*/
if (!treeNodes.ContainsKey(rel.destId) && objectsCI.ContainsKey(rel.destId))
{
FMTreeNode placeholder = new FMTreeNode();
placeholder.baseModelObject = objectsCI[rel.destId];
placeholder.isNew = true;
placeholder.isPlaceholder = true;
treeNodes[rel.destId] = placeholder;
if (DEBUG)
{
_OutputListener.writeOutput("[DEBUG] Created PLACEHOLDER for {0}", objectsCI[rel.destId].name);
}
}
/**
* Check if both source and destination objects are there, if not ignore this relationship.
*/
if (treeNodes.ContainsKey(rel.destId) && objectsCI.ContainsKey(rel.sourceId))
{
FMTreeNode node = treeNodes[rel.destId];
/**
* Dependency with Generalization/Aggregation-stereotype is used as Work-around
* for Package Generalization/Aggregation (which is not possible / allowed in UML)
* e.g. used for new Functions
*/
if (rel.type == RelationshipTypeEnum.Dependency)
{
if ("Generalization".Equals(rel.stereotype))
{
rel.type = RelationshipTypeEnum.Generalization;
}
if ("Aggregation".Equals(rel.stereotype))
{
rel.type = RelationshipTypeEnum.Aggregation;
}
}
/**
* Generalization relationship means this is a change to an existing base model element
*/
if (rel.type == RelationshipTypeEnum.Generalization)
{
node.instructionObject = objectsCI[rel.sourceId];
node.includeInProfile = true;
}
/**
* Aggregation relationship means this is a new child element
*/
else if (rel.type == RelationshipTypeEnum.Aggregation)
{
if (treeNodes.ContainsKey(rel.sourceId) && treeNodes[rel.sourceId].isPlaceholder)
{
FMTreeNode placeholder = treeNodes[rel.sourceId];
placeholder.parent = node;
placeholder.isPlaceholder = false;
placeholder.includeInProfile = true;
setCompilerInclusionReason(placeholder, "New from ProfileDefinition; via PLACEHOLDER");
node.children.Add(placeholder);
if (!node.includeInProfile)
{
node.includeInProfile = true;
setCompilerInclusionReason(node, "Because of new child");
}
}
else if (objectsCI[rel.sourceId].tag != null && objectsCI[rel.sourceId].tag.Any(t => TV_INCLUSIONREASON.Equals(t.name)))
{
_OutputListener.writeOutput("[WARN] Already new {0}. Check Aggregation relationships!", objectsCI[rel.sourceId].name);
}
else
{
// Create the new node
FMTreeNode newNode = new FMTreeNode();
newNode.baseModelObject = objectsCI[rel.sourceId];
newNode.baseModelObject.parentId = node.baseModelObject.id;
newNode.parent = node;
newNode.isNew = true;
newNode.includeInProfile = true;
setCompilerInclusionReason(newNode, "New from ProfileDefinition");
node.children.Add(newNode);
if (!node.includeInProfile)
{
node.includeInProfile = true;
setCompilerInclusionReason(node, "Because of new child");
}
treeNodes[rel.sourceId] = newNode;
}
}
/**
* Other relationship types not supported
*/
else
{
if (DEBUG)
{
_OutputListener.writeOutput("[DEBUG] Ignored {0}", rel.type);
}
}
}
else
{
if (DEBUG)
{
/**
* Check if destination is inside Profile Definition.
* E.g. for internal relationships in Profile Definition or for new elements.
*/
if (objectsCI.ContainsKey(rel.destId))
{
string srcName = rel.sourceId;
if (objectsCI[rel.sourceId].name != null)
{
srcName = objectsCI[rel.sourceId].name.Split(new[] { ' ' })[0];
}
string dstName = rel.sourceId;
if (objectsCI[rel.destId].name != null)
{
dstName = objectsCI[rel.destId].name.Split(new[] { ' ' })[0];
}
_OutputListener.writeOutput("[DEBUG] Ignored {0} from {1} to {2} inside ProfileDefinition", rel.type, srcName, dstName, parseIdForConsole(rel.sourceId));
}
else
{
// E.g. for ExternalReferences
_OutputListener.writeOutput("[DEBUG] Ignored {0} from {1} to id={2} outside BaseModel", rel.type, objectsCI[rel.sourceId].name, rel.destId, parseIdForConsole(rel.sourceId));
}
}
}
}
ObjectType profileDefinition = objectsCI.Values.Single(o => R2Const.ST_FM_PROFILEDEFINITION.Equals(o.stereotype));
string rootid = root.baseModelObject.id;
root.baseModelObject = new ObjectType()
{
id = rootid,
name = profileDefinition.name,
stereotype = R2Const.ST_FM_PROFILE,
type = ObjectTypeEnum.Package,
typeSpecified = true,
tag = profileDefinition.tag
};
}
// Only follow ConsequenceLinks for ProfileType != Companion
bool doFollowConsequenceLinks = true;
if (root.baseModelObject.tag.Any(t => "Type".Equals(t.name)))
{
TagType typeTag = FirstOrDefaultNonEmptyValue(root.baseModelObject.tag, "Type");
doFollowConsequenceLinks = !"Companion".Equals(typeTag.value);
}
// Exclude and exclude consequenceLinks when Criterion is Excluded
exclude(root);
// Now auto include parents and criterions and included consequenceLinks
autoInclude(root, doFollowConsequenceLinks);
// Compile aka execute compiler instructions
executeInstructions(root, PRIORITY_ESSENTIALNOW);
// Give profile elements new unique ids
// Only what is still in the Tree!
List <ObjectType> objects = root.ToObjectList();
Dictionary <string, string> idOrg2idNew = new Dictionary <string, string>();
foreach (ObjectType maxObj in objects)
{
string idOrg = maxObj.id;
string idNew = Guid.NewGuid().ToString();
idOrg2idNew[idOrg] = idNew;
maxObj.id = idNew;
// Also remove modified date
maxObj.modifiedSpecified = false;
}
// Set new (gu)id's in objects parentId
foreach (ObjectType maxObj in objects)
{
if (!string.IsNullOrEmpty(maxObj.parentId))
{
if (idOrg2idNew.ContainsKey(maxObj.parentId))
{
maxObj.parentId = idOrg2idNew[maxObj.parentId];
}
else
{
// object already has new id assigned, which is also not an integer!
_OutputListener.writeOutput("[WARN] Already has new id: {0}", maxObj.name.Split(new[] { ' ' })[0], -1);
}
}
}
// Set new (gu)id's for relationships
List <RelationshipType> relationships = root.ToRelationshipList();
foreach (RelationshipType maxRel in relationships)
{
if (idOrg2idNew.ContainsKey(maxRel.sourceId))
{
maxRel.sourceId = idOrg2idNew[maxRel.sourceId];
}
if (idOrg2idNew.ContainsKey(maxRel.destId))
{
maxRel.destId = idOrg2idNew[maxRel.destId];
}
}
// Remove relationships to objects that are not included
foreach (RelationshipType maxRel in relationships.ToArray())
{
if (!objects.Any(t => t.id == maxRel.sourceId))
{
string sourceId = idOrg2idNew.Single(t => t.Value == maxRel.sourceId).Key;
string destName = objects.Single(t => t.id == maxRel.destId).name;
_OutputListener.writeOutput("[WARN] Relationship from not included object removed (sourceId={0} destId={1} stereotype={2} destName={3})", sourceId, maxRel.destId, maxRel.stereotype, destName);
relationships.Remove(maxRel);
}
if (!objects.Any(t => t.id == maxRel.destId))
{
string sourceId = idOrg2idNew.Single(t => t.Value == maxRel.sourceId).Key;
string sourceName = objects.Single(t => t.id == maxRel.sourceId).name;
_OutputListener.writeOutput("[WARN] Relationship to not included object removed (sourceId={0} destId={1} stereotype={2} sourceName={3})", sourceId, maxRel.destId, maxRel.stereotype, sourceName);
relationships.Remove(maxRel);
}
}
// Convert back to MAX model
ModelType model = new ModelType();
model.exportDate = Util.FormatLastModified(DateTime.Now);
model.objects = objects.ToArray();
model.relationships = relationships.ToArray();
// Save compiled profile as MAX XML
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.NewLineChars = "\n";
using (XmlWriter writer = XmlWriter.Create(fileNameOutput, settings))
{
serializer.Serialize(writer, model);
}
}
}
/// <summary>
/// Generates code that implements standard features of a model, including
/// equality checks, hash code generation, cloning methods, and a friendly ToString().
/// </summary>
/// <param name="modelType">The type of model.</param>
/// <returns>
/// Generated code that implements the standard features for the specified model type.
/// </returns>
public static string GenerateCodeForModelImplementation(
this ModelType modelType)
{
new { modelType }.AsArg().Must().NotBeNull();
var modelImplementationItems = new List <string>();
if (modelType.RequiresEquality)
{
modelImplementationItems.Add(string.Empty);
modelImplementationItems.Add(modelType.GenerateEqualityMethods());
}
if (modelType.RequiresComparability)
{
modelImplementationItems.Add(string.Empty);
modelImplementationItems.Add(modelType.GenerateComparableMethods());
}
if (modelType.RequiresHashing)
{
var hashingMethods = modelType.GenerateHashingMethods();
if (!string.IsNullOrWhiteSpace(hashingMethods))
{
modelImplementationItems.Add(string.Empty);
modelImplementationItems.Add(hashingMethods);
}
}
if (modelType.RequiresDeepCloning)
{
modelImplementationItems.Add(string.Empty);
modelImplementationItems.Add(modelType.GenerateCloningMethods());
}
if (modelType.RequiresStringRepresentation)
{
var stringRepresentationMethods = modelType.GenerateStringRepresentationMethods();
if (!string.IsNullOrWhiteSpace(stringRepresentationMethods))
{
modelImplementationItems.Add(string.Empty);
modelImplementationItems.Add(stringRepresentationMethods);
}
}
var modelImplementationCode = modelImplementationItems.Where(_ => _ != null).ToNewLineDelimited();
var codeTemplate = typeof(ModelImplementationGeneration).GetCodeTemplate(CodeTemplateKind.Model, KeyMethodKinds.Both);
var result = codeTemplate
.Replace(Tokens.UsingStatementsToken, modelType.GetUsingStatementsForModelObject())
.Replace(Tokens.CodeGenAssemblyNameToken, GenerationShared.GetCodeGenAssemblyName())
.Replace(Tokens.CodeGenAssemblyVersionToken, GenerationShared.GetCodeGenAssemblyVersion())
.Replace(Tokens.ModelTypeNamespaceToken, modelType.TypeNamespace)
.Replace(Tokens.ModelTypeNameInCodeToken, modelType.TypeNameInCodeString)
.Replace(Tokens.RequiredInterfacesToken, modelType.RequiredInterfaces.Select(_ => _.ToStringReadable()).ToDelimitedString(", "))
.Replace(Tokens.ModelImplementationToken, modelImplementationCode);
return(result);
}
public override int GetHashCode()
{
int hash = 1;
if (ModelName.Length != 0)
{
hash ^= ModelName.GetHashCode();
}
if (ModelType.Length != 0)
{
hash ^= ModelType.GetHashCode();
}
if (InputBlob.Length != 0)
{
hash ^= InputBlob.GetHashCode();
}
if (OutputBlob.Length != 0)
{
hash ^= OutputBlob.GetHashCode();
}
if (WeightFile.Length != 0)
{
hash ^= WeightFile.GetHashCode();
}
if (ProtoFile.Length != 0)
{
hash ^= ProtoFile.GetHashCode();
}
if (ClassifyThreshold != 0F)
{
hash ^= ClassifyThreshold.GetHashCode();
}
if (ClassifyResizeWidth != 0)
{
hash ^= ClassifyResizeWidth.GetHashCode();
}
if (ClassifyResizeHeight != 0)
{
hash ^= ClassifyResizeHeight.GetHashCode();
}
if (Scale != 0F)
{
hash ^= Scale.GetHashCode();
}
if (MeanB != 0F)
{
hash ^= MeanB.GetHashCode();
}
if (MeanG != 0F)
{
hash ^= MeanG.GetHashCode();
}
if (MeanR != 0F)
{
hash ^= MeanR.GetHashCode();
}
if (IsBgr != false)
{
hash ^= IsBgr.GetHashCode();
}
return(hash);
}
public static string GenerateCodeForTests(
this ModelType modelType,
GenerateFor kind)
{
var testImplementationItems = new List <string>();
if (modelType.RequiresStringRepresentation)
{
var stringFieldsCode = modelType.GenerateStringRepresentationTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (!string.IsNullOrWhiteSpace(stringFieldsCode))
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(stringFieldsCode);
}
}
if (modelType.RequiresModel)
{
var constructorFieldsCode = modelType.GenerateConstructorTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (constructorFieldsCode != null)
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(constructorFieldsCode);
}
}
if (modelType.RequiresDeepCloning)
{
var deepCloneWithFieldsCode = modelType.GenerateDeepCloneWithTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (!string.IsNullOrWhiteSpace(deepCloneWithFieldsCode))
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(deepCloneWithFieldsCode);
}
}
if (modelType.RequiresEquality || modelType.RequiresHashing)
{
var equalityFieldsCode = modelType.GenerateEqualityTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (equalityFieldsCode != null)
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(equalityFieldsCode);
}
}
if (modelType.RequiresComparability)
{
var comparableTestFields = modelType.GenerateComparableTestFields().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(comparableTestFields);
}
var structuralTestMethodsCode = modelType.GenerateStructuralTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(structuralTestMethodsCode);
if (modelType.RequiresStringRepresentation)
{
var stringTestMethodsCode = modelType.GenerateStringRepresentationTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (!string.IsNullOrWhiteSpace(stringTestMethodsCode))
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(stringTestMethodsCode);
}
}
if (modelType.RequiresModel)
{
var constructorTestMethodsCode = modelType.GenerateConstructorTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
if (constructorTestMethodsCode != null)
{
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(constructorTestMethodsCode);
}
}
if (modelType.RequiresDeepCloning)
{
var cloningTestMethodsCode = modelType.GenerateCloningTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(cloningTestMethodsCode);
}
if (kind.HasFlag(GenerateFor.ModelImplementationTestsPartialClassWithSerialization) && modelType.RequiresModel)
{
var serializationTestMethodsCode = modelType.GenerateSerializationTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(serializationTestMethodsCode);
}
if (modelType.RequiresEquality)
{
var equalityTestMethodsCode = modelType.GenerateEqualityTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(equalityTestMethodsCode);
}
if (modelType.RequiresHashing)
{
var hashingTestMethodsCode = modelType.GenerateHashingTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(hashingTestMethodsCode);
}
if (modelType.RequiresComparability)
{
var comparabilityTestMethodsCode = modelType.GenerateComparabilityTestMethods().ReplaceCodeAnalysisSuppressionTokensInTestCode();
testImplementationItems.Add(string.Empty);
testImplementationItems.Add(comparabilityTestMethodsCode);
}
var testImplementationCode = testImplementationItems.Where(_ => _ != null).ToNewLineDelimited();
var codeTemplate = typeof(ModelImplementationGeneration).GetCodeTemplate(CodeTemplateKind.Test, KeyMethodKinds.Both);
var result = codeTemplate
.Replace(Tokens.UsingStatementsToken, modelType.GetUsingStatementsForTestClass(kind))
.Replace(Tokens.CodeGenAssemblyNameToken, GenerationShared.GetCodeGenAssemblyName())
.Replace(Tokens.CodeGenAssemblyVersionToken, GenerationShared.GetCodeGenAssemblyVersion())
.Replace(Tokens.ModelTypeNamespaceToken, modelType.TypeNamespace)
.Replace(Tokens.ModelTypeNameInCodeToken, modelType.TypeNameInCodeString)
.Replace(Tokens.ModelTypeNameInTestClassNameToken, modelType.TypeNameInTestClassNameString)
.Replace(Tokens.TestImplementationToken, testImplementationCode);
return(result);
}
/**
* Updates HandRepresentations based in the specified HandRepresentation Dictionary.
* Active HandRepresentation instances are updated if the hand they represent is still
* present in the Provider's CurrentFrame; otherwise, the HandRepresentation is removed. If new
* Leap Hand objects are present in the Leap HandRepresentation Dictionary, new HandRepresentations are
* created and added to the dictionary.
* @param all_hand_reps = A dictionary of Leap Hand ID's with a paired HandRepresentation
* @param modelType Filters for a type of hand model, for example, physics or graphics hands.
* @param frame The Leap Frame containing Leap Hand data for each currently tracked hand
*/
protected virtual void UpdateHandRepresentations(Dictionary <int, HandRepresentation> all_hand_reps, ModelType modelType, Frame frame)
{
for (int i = 0; i < frame.Hands.Count; i++)
{
var curHand = frame.Hands[i];
HandRepresentation rep;
if (!all_hand_reps.TryGetValue(curHand.Id, out rep))
{
rep = factory.MakeHandRepresentation(curHand, modelType);
if (rep != null)
{
all_hand_reps.Add(curHand.Id, rep);
}
}
if (rep != null)
{
rep.IsMarked = true;
rep.UpdateRepresentation(curHand);
rep.LastUpdatedTime = (int)frame.Timestamp;
}
}
/** Mark-and-sweep to finish unused HandRepresentations */
HandRepresentation toBeDeleted = null;
for (var it = all_hand_reps.GetEnumerator(); it.MoveNext();)
{
var r = it.Current;
if (r.Value != null)
{
if (r.Value.IsMarked)
{
r.Value.IsMarked = false;
}
else
{
/** Initialize toBeDeleted with a value to be deleted */
//Debug.Log("Finishing");
toBeDeleted = r.Value;
}
}
}
/**Inform the representation that we will no longer be giving it any hand updates
* because the corresponding hand has gone away */
if (toBeDeleted != null)
{
all_hand_reps.Remove(toBeDeleted.HandID);
toBeDeleted.Finish();
}
}
public static AbstractResearchDraw CreateResearchDraw(ResearchType researchType, ModelType modelType)
{
switch (researchType)
{
case ResearchType.Basic:
return(new BasicResearchDraw(modelType));
case ResearchType.Activation:
return(new ActivationResearchDraw());
case ResearchType.Evolution:
return(new EvolutionResearchDraw());
default:
Debug.Assert(false);
return(null);
}
}
public ModelSaberOnlineUserControl(MainWindow mainWindow, ModelType modelType)
{
InitializeComponent();
ViewModel = new ModelSaberOnlineUserControlViewModel(mainWindow, this, modelType);
DataContext = ViewModel;
}
public RazorPageWithContextTemplateModel2(ModelType modelType, string dbContextFullTypeName)
: base(modelType, dbContextFullTypeName)
{
}
public GenConverDtoTotEF(ModelType model, ColumnSetNode columnSetNode)
{
this.Model = model;
this.ColumnSetNode = columnSetNode;
}
public BussinessException(ModelType modelID, ushort innerExceptionID, string message = null)
: base((byte)modelID, innerExceptionID, message)
{
}
/// <summary>
/// Attempt to infer a query request from an instance object.
/// </summary>
/// <param name="instance"></param>
/// <param name="type"></param>
/// <param name="roots"></param>
/// <param name="isList"></param>
/// <returns></returns>
internal static bool TryConvertQueryInstance(object instance, out ModelType type, out ModelInstance[] roots, out bool isList)
{
// Default the out parameters to null
type = null;
roots = null;
isList = false;
// Immediately return null if the query instance is null
if (instance == null)
{
return(false);
}
// Get the current model context
var context = ModelContext.Current;
// Determine if the instance is a model instance
type = context.GetModelType(instance);
if (type != null)
{
roots = new ModelInstance[] { type.GetModelInstance(instance) };
if (roots[0].Type.Properties.Any())
{
roots[0].OnPropertyGet(roots[0].Type.Properties.First());
}
isList = false;
return(true);
}
// Otherwise, determine if the instance is a list of model instances
else if (instance is IEnumerable)
{
// Convert the list to an array of model instances
roots =
(
from element in ((IEnumerable)instance).Cast <object>()
let elementType = context.GetModelType(element)
where elementType != null
select elementType.GetModelInstance(element)
).ToArray();
// Indicate that the instance represents a list
isList = true;
// If the array contains at least one model instance, determine the base model type
if (roots.Length > 0)
{
type = roots[0].Type;
foreach (var rootType in roots.Select(r => r.Type))
{
if (rootType.IsSubType(type))
{
type = rootType;
}
else if (type != rootType)
{
while (!(type.IsSubType(rootType)))
{
type = type.BaseType;
}
}
}
return(true);
}
// Otherwise, attempt to infer the model type from the type of the list
else
{
// First see if the type implements IEnumerable<T>
var listType = instance.GetType();
foreach (Type interfaceType in listType.GetInterfaces())
{
if (interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == typeof(ICollection <>))
{
type = context.GetModelType(interfaceType.GetGenericArguments()[0]);
if (type != null)
{
return(true);
}
}
}
// Then see if the type implements IList and has a strongly-typed Item property indexed by an integer value
if (typeof(IList).IsAssignableFrom(listType))
{
PropertyInfo itemProperty = listType.GetProperty("Item", new Type[] { typeof(int) });
if (itemProperty != null)
{
type = context.GetModelType(itemProperty.PropertyType);
if (type != null)
{
return(true);
}
}
}
}
}
// Return false to indicate that the instance could not be coerced into a valid query definition
return(false);
}
public GenRepository(ModelType model)
{
this.Model = model;
}
protected ProductBaseModel([NotNull] DeclarationSymbol symbol, ModelType modelType)
: base(symbol, modelType)
{
}
public void GenerateShipHulk(SpaceShip ship, ShipData shipData, ModelType mesh1, ModelType mesh2)
{
if (shipData.numChunks <= 0)
{
return;
}
//chunks are evenly distributed to the front and rear of the ship. The
// front chunks are propelled forward, and rear chunks are propelled backward.
for (int i = 0; i < shipData.numChunks; i++)
{
//first, find a random spot to spawn the hulk within the ship bounding perimeter.
Vector2 spawnPos = Vector2.Zero; //X = WIDTH, Y = LENGTH.
spawnPos.X = MathHelper.Lerp(shipData.shipWidth / -2, shipData.shipWidth / 2,
(float)FrameworkCore.r.NextDouble());
spawnPos.Y = MathHelper.Lerp(0.1f, shipData.shipLength / 2,
(float)FrameworkCore.r.NextDouble());
if (i % 2 == 0)
{
spawnPos.Y *= -1f;
}
Matrix orientationMatrix = Matrix.CreateFromQuaternion(ship.Rotation);
Vector3 spawnPosition = ship.Position +
orientationMatrix.Forward * spawnPos.Y +
orientationMatrix.Right * spawnPos.X;
//now, generate the direction the hulk will move.
Vector3 moveDir = Vector3.Zero;
if (spawnPos.Y > 0)
{
//chunk spawned in front of ship. propel it forward.
moveDir = orientationMatrix.Forward;
}
else
{
moveDir = orientationMatrix.Backward;
}
//add some random variance to the move direction.
moveDir += orientationMatrix.Right * MathHelper.Lerp(-0.5f, 0.5f, (float)FrameworkCore.r.NextDouble());
moveDir += orientationMatrix.Up * MathHelper.Lerp(-0.5f, 0.5f, (float)FrameworkCore.r.NextDouble());
ModelType mesh = ModelType.debrisHulk1;
if (i % 2 == 0)
{
mesh = mesh1;
}
else
{
mesh = mesh2;
}
//spawn the hulk.
AddHulk(mesh, ship, spawnPosition, moveDir);
for (int k = 0; k < 16; k++)
{
Vector3 debrisMoveDir = moveDir;
debrisMoveDir += orientationMatrix.Right * MathHelper.Lerp(-0.5f, 0.5f, (float)FrameworkCore.r.NextDouble());
debrisMoveDir += orientationMatrix.Up * MathHelper.Lerp(-0.5f, 0.5f, (float)FrameworkCore.r.NextDouble());
FrameworkCore.debrisManager.AddDebris(getRandomDebris(),
spawnPosition, debrisMoveDir);
}
}
}
public void OnTypeChange(int value)
{
type = (ModelType)(value + 1);
}
private (PublishedContentType, PublishedContentType) CreateContentTypes()
{
Current.Reset();
var logger = Mock.Of <ILogger>();
var profiler = Mock.Of <IProfiler>();
var proflog = new ProfilingLogger(logger, profiler);
PropertyEditorCollection editors = null;
var editor = new NestedContentPropertyEditor(logger, new Lazy <PropertyEditorCollection>(() => editors));
editors = new PropertyEditorCollection(new DataEditorCollection(new DataEditor[] { editor }));
var dataType1 = new DataType(editor)
{
Id = 1,
Configuration = new NestedContentConfiguration
{
MinItems = 1,
MaxItems = 1,
ContentTypes = new[]
{
new NestedContentConfiguration.ContentType {
Alias = "contentN1"
}
}
}
};
var dataType2 = new DataType(editor)
{
Id = 2,
Configuration = new NestedContentConfiguration
{
MinItems = 1,
MaxItems = 99,
ContentTypes = new[]
{
new NestedContentConfiguration.ContentType {
Alias = "contentN1"
}
}
}
};
var dataType3 = new DataType(new TextboxPropertyEditor(logger))
{
Id = 3
};
// mocked dataservice returns nested content preValues
var dataTypeService = new TestObjects.TestDataTypeService(dataType1, dataType2, dataType3);
var publishedModelFactory = new Mock <IPublishedModelFactory>();
// mocked model factory returns model type
var modelTypes = new Dictionary <string, Type>
{
{ "contentN1", typeof(TestElementModel) }
};
publishedModelFactory
.Setup(x => x.MapModelType(It.IsAny <Type>()))
.Returns((Type type) => ModelType.Map(type, modelTypes));
// mocked model factory creates models
publishedModelFactory
.Setup(x => x.CreateModel(It.IsAny <IPublishedElement>()))
.Returns((IPublishedElement element) =>
{
if (element.ContentType.Alias.InvariantEquals("contentN1"))
{
return(new TestElementModel(element));
}
return(element);
});
// mocked model factory creates model lists
publishedModelFactory
.Setup(x => x.CreateModelList(It.IsAny <string>()))
.Returns((string alias) =>
{
return(alias == "contentN1"
? (IList) new List <TestElementModel>()
: (IList) new List <IPublishedElement>());
});
var contentCache = new Mock <IPublishedContentCache>();
var publishedSnapshot = new Mock <IPublishedSnapshot>();
// mocked published snapshot returns a content cache
publishedSnapshot
.Setup(x => x.Content)
.Returns(contentCache.Object);
var publishedSnapshotAccessor = new Mock <IPublishedSnapshotAccessor>();
// mocked published snapshot accessor returns a facade
publishedSnapshotAccessor
.Setup(x => x.PublishedSnapshot)
.Returns(publishedSnapshot.Object);
var converters = new PropertyValueConverterCollection(new IPropertyValueConverter[]
{
new NestedContentSingleValueConverter(publishedSnapshotAccessor.Object, publishedModelFactory.Object, proflog),
new NestedContentManyValueConverter(publishedSnapshotAccessor.Object, publishedModelFactory.Object, proflog),
});
var factory = new PublishedContentTypeFactory(publishedModelFactory.Object, converters, dataTypeService);
var propertyType1 = factory.CreatePropertyType("property1", 1);
var propertyType2 = factory.CreatePropertyType("property2", 2);
var propertyTypeN1 = factory.CreatePropertyType("propertyN1", 3);
var contentType1 = factory.CreateContentType(1, "content1", new[] { propertyType1 });
var contentType2 = factory.CreateContentType(2, "content2", new[] { propertyType2 });
var contentTypeN1 = factory.CreateContentType(2, "contentN1", new[] { propertyTypeN1 });
// mocked content cache returns content types
contentCache
.Setup(x => x.GetContentType(It.IsAny <string>()))
.Returns((string alias) =>
{
if (alias.InvariantEquals("contentN1"))
{
return(contentTypeN1);
}
return(null);
});
return(contentType1, contentType2);
}
// Constructors
/// <summary>
/// Initializes new instance of this type.
/// </summary>
/// <param name="model">The model.</param>
/// <param name="path">The path.</param>
public HintTarget(ModelType model, string path)
{
this.model = model;
this.path = path;
}
/// <summary>
/// Creates a new instance of ArgumentInfo. Type is indicated as ModelType. Value is not set.
/// </summary>
/// <param name="name">Name of the argument.</param>
/// <param name="type">Type of the argument.</param>
public ArgumentInfo(string name, ModelType type, string className)
: this(name, type, null, className)
{
}
public InvalidPropertyException(ModelType type, string name)
: base("Invalid property: " + type.Name + "." + name)
{
}
void Awake()
{
MasterClientManager = FindObjectOfType <MasterClientManager>();
//Force SpawnCollection Awake() method for initialization
SpawnCollection spawnCollection = FindObjectOfType <SpawnCollection>();
spawnCollection.gameObject.SetActive(false);
spawnCollection.gameObject.SetActive(true);
//Force SkillCollection Awake() method for initialization
SkillCollection skillList = FindObjectOfType <SkillCollection>();
skillList.gameObject.SetActive(false);
skillList.gameObject.SetActive(true);
AuthoryClient = new AuthoryClient(MasterClientManager.GetMapServerAuthString());
AuthoryClient.Connect(MasterClientManager.MapServerIP, MasterClientManager.MapServerPort, MasterClientManager.MapServerUID);
NetIncomingMessage msgIn;
bool playerInfoArrived = false;
DateTime start = DateTime.Now.AddSeconds(5);
while (playerInfoArrived != true)
{
if (start < DateTime.Now)
{
return;
}
else
{
while ((msgIn = AuthoryClient.Client.ReadMessage()) != null)
{
if (msgIn.MessageType == NetIncomingMessageType.Data)
{
if (((MessageType)msgIn.ReadByte()) == MessageType.PlayerID)
{
ushort Id = msgIn.ReadUInt16();
string Name = msgIn.ReadString();
int maxHealth = msgIn.ReadInt32();
int health = msgIn.ReadInt32();
int maxMana = msgIn.ReadInt32();
int mana = msgIn.ReadInt32();
byte level = msgIn.ReadByte();
ModelType modelType = (ModelType)msgIn.ReadByte();
float x = msgIn.ReadFloat();
float z = msgIn.ReadFloat();
float movementSpeed = msgIn.ReadFloat();
ushort END = msgIn.ReadUInt16();
ushort STR = msgIn.ReadUInt16();
ushort AGI = msgIn.ReadUInt16();
ushort INT = msgIn.ReadUInt16();
ushort KNW = msgIn.ReadUInt16();
ushort LCK = msgIn.ReadUInt16();
long experience = msgIn.ReadInt64();
long maxExperience = msgIn.ReadInt64();
AuthoryClient.Handler.SetMapSize(msgIn.ReadInt32());
GameObject entity = AuthoryClient.Handler.GetEntityObjectByModelType(modelType).gameObject;
GameObject.Destroy(entity.GetComponent <Entity>());
PlayerEntity playerEntity = entity.AddComponent <PlayerEntity>();
entity.AddComponent <PlayerMove>();
Camera.main.GetComponent <CameraOrbit>().Target = playerEntity.transform;
AuthoryData.Instance.SetPlayer(playerEntity, Id, Name);
playerEntity.transform.position = new Vector3(x, 0, z);
playerEntity.SetMaxHealth(maxHealth);
playerEntity.SetHealth((ushort)health);
playerEntity.SetMaxMana(maxMana);
playerEntity.SetMana((ushort)mana);
playerEntity.Level = level;
playerEntity.MovementSpeed = movementSpeed;
playerEntity.Attributes.Endurance = END;
playerEntity.Attributes.Strength = STR;
playerEntity.Attributes.Agility = AGI;
playerEntity.Attributes.Intelligence = INT;
playerEntity.Attributes.Knowledge = KNW;
playerEntity.Attributes.Luck = LCK;
AuthoryClient.UIController.Player = playerEntity;
AuthoryClient.UIController.UpdateMaxExperience(maxExperience, experience);
playerInfoArrived = true;
break;
}
}
}
}
}
AuthorySender.Movement();
}
public static GameObject MountModel(string _id, Transform _parent, MaterialPair _materialPair, ModelType _type = ModelType.AnturaForniture)
{
CleanTranformChildren(_parent);
GameObject returnObject = MountModel(_id, _parent, _type);
Reward actualReward = RewardSystemManager.GetRewardById(_id);
SwitchMaterial(returnObject, _materialPair);
return(returnObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="NodeRepository" /> class.
/// </summary>
/// <param name="typeOfModel">The type of model for which to store nodes</param>
public NodeRepository(ModelType typeOfModel)
{
this.ModelType = typeOfModel;
}
