// Use this for initialization
void Start()
{
cam = GameObject.Find("FP_Camera").GetComponent <Camera>();
cam2 = GameObject.Find("3D_Camera").GetComponent <Camera>();
state = GameObject.Find("GAME").GetComponent <Game>();
move = GameObject.Find("3D_Map").GetComponent <ConstructorMap>();
name = GameObject.Find("Dude").GetComponent <Movement> ();
clicked = false;
moving = false;
exchange = false;
excParent = this.transform.parent.gameObject;
if (this.gameObject == excParent.transform.GetChild(1).gameObject)
{
excSection = excParent.transform.GetChild(0).gameObject;
}
else
{
excSection = excParent.transform.GetChild(1).gameObject;
}
map = new GameObject[2];
map2 = new GameObject[2];
render1 = this.gameObject.transform.GetComponent <MeshRenderer> ();
positionY = this.gameObject.transform.position.y;
positionYEx = excSection.gameObject.transform.position.y;
}
private Expression CreateNewDestinationExpression(ConstructorMap constructorMap)
{
var ctorArgs = constructorMap.CtorParams.Select(CreateConstructorParameterExpression);
var variables = constructorMap.Ctor.GetParameters().Select(parameter => Variable(parameter.ParameterType, parameter.Name)).ToArray();
var body = variables.Zip(ctorArgs,
(variable, expression) => (Expression)Assign(variable, ToType(expression, variable.Type)))
.Concat(new[] { CheckReferencesCache(New(constructorMap.Ctor, variables)) })
.ToArray();
return(Block(variables, body));
}
private Expression CreateNewDestinationExpression(ConstructorMap constructorMap)
{
if (!constructorMap.CanResolve)
{
return(null);
}
var ctorArgs = constructorMap.CtorParams.Select(CreateConstructorParameterExpression);
ctorArgs =
ctorArgs.Zip(constructorMap.Ctor.GetParameters(),
(exp, pi) => exp.Type == pi.ParameterType ? exp : Convert(exp, pi.ParameterType))
.ToArray();
var newExpr = New(constructorMap.Ctor, ctorArgs);
return(newExpr);
}
// Use this for initialization
void Start()
{
cam = GameObject.Find("FP_Camera").GetComponent <Camera>();
cam2 = GameObject.Find("3D_Camera").GetComponent <Camera>();
state = GameObject.Find("GAME").GetComponent <Game>();
move = GameObject.Find("3D_Map").GetComponent <ConstructorMap>();
name = GameObject.Find("Dude").GetComponent <Movement> ();
clicked = false;
moving = false;
rotatRight = false;
rotatLeft = false;
rot = 0;
map = new GameObject[2];
render1 = this.gameObject.transform.GetChild(0).GetComponent <MeshRenderer> ();
render2 = this.gameObject.transform.GetChild(0).GetChild(0).GetComponent <MeshRenderer> ();
positionY = this.gameObject.transform.GetChild(0).transform.position.y;
}
private void MapDestinationCtorToSource(TypeMap typeMap, List <ICtorParameterConfiguration> ctorParamConfigurations)
{
var ctorMap = typeMap.ConstructorMap;
if (ctorMap != null)
{
foreach (var paramMap in ctorMap.CtorParams)
{
paramMap.CanResolveValue = paramMap.CanResolveValue || IsConfigured(paramMap.Parameter);
}
return;
}
if (typeMap.DestinationType.IsAbstract || !typeMap.Profile.ConstructorMappingEnabled)
{
return;
}
foreach (var destCtor in typeMap.DestinationTypeDetails.Constructors.OrderByDescending(ci => ci.GetParameters().Length))
{
var ctorParameters = destCtor.GetParameters();
if (ctorParameters.Length == 0)
{
break;
}
ctorMap = new ConstructorMap(destCtor, typeMap);
foreach (var parameter in ctorParameters)
{
var resolvers = new LinkedList <MemberInfo>();
var canResolve = typeMap.Profile.MapDestinationPropertyToSource(typeMap.SourceTypeDetails, destCtor.DeclaringType, parameter.GetType(), parameter.Name, resolvers, IsReverseMap);
if ((!canResolve && parameter.IsOptional) || IsConfigured(parameter))
{
canResolve = true;
}
ctorMap.AddParameter(parameter, resolvers.ToArray(), canResolve);
}
typeMap.ConstructorMap = ctorMap;
if (ctorMap.CanResolve)
{
break;
}
}
return;
bool IsConfigured(ParameterInfo parameter) => ctorParamConfigurations.Any(c => c.CtorParamName == parameter.Name);
}
public Expression NewExpression(ConstructorMap constructorMap, ExpressionRequest request, Expression instanceParameter, TypePairCount typePairCount, LetPropertyMaps letPropertyMaps)
{
var parameters = constructorMap.CtorParams.Select(map =>
{
var resolvedSource = ResolveExpression(map, request.SourceType, instanceParameter, letPropertyMaps);
var types = new TypePair(resolvedSource.Type, map.DestinationType);
var typeMap = _configurationProvider.ResolveTypeMap(types);
if (typeMap == null)
{
if (types.DestinationType.IsAssignableFrom(types.SourceType))
{
return(resolvedSource.ResolutionExpression);
}
ThrowCannotMap(map, resolvedSource);
}
var newRequest = new ExpressionRequest(types.SourceType, types.DestinationType, request.MembersToExpand, request);
return(CreateMapExpressionCore(newRequest, resolvedSource.ResolutionExpression, typePairCount, typeMap, letPropertyMaps));
});
return(New(constructorMap.Ctor, parameters));
}
private void MapDestinationCtorToSource(TypeMap typeMap)
{
var sourceMembers = new List <MemberInfo>();
foreach (var destCtor in typeMap.DestinationConstructors)
{
var constructor = destCtor.Constructor;
var ctorMap = new ConstructorMap(constructor, typeMap);
bool canMapResolve = true;
foreach (var parameter in destCtor.Parameters)
{
sourceMembers.Clear();
var canResolve = typeMap.Profile.MapDestinationPropertyToSource(typeMap.SourceTypeDetails, constructor.DeclaringType, parameter.ParameterType, parameter.Name, sourceMembers, IsReverseMap);
if (!canResolve)
{
if (parameter.IsOptional || IsConfigured(parameter))
{
canResolve = true;
}
else
{
canMapResolve = false;
}
}
ctorMap.AddParameter(parameter, sourceMembers, canResolve);
}
typeMap.ConstructorMap = ctorMap;
if (canMapResolve)
{
ctorMap.CanResolve = true;
break;
}
}
return;
bool IsConfigured(ParameterInfo parameter) => _ctorParamConfigurations?.Any(c => c.CtorParamName == parameter.Name) is true;
}
private void CreateConstructorMap()
{
_constructorMap = new ConstructorMap(_constructorQueryProviderMock.Object, typeof(SomeType));
}
