internal DynamicSpawnZoneOverloadBlockBase(BinaryReader binaryReader)
{
this.overloadType = (OverloadType)binaryReader.ReadInt16();
this.invalidName_ = binaryReader.ReadBytes(2);
this.innerRadius = binaryReader.ReadSingle();
this.outerRadius = binaryReader.ReadSingle();
this.weight = binaryReader.ReadSingle();
}
public static Type GetOverloadType(Type elementType, OverloadType overload)
{
switch (overload)
{
case OverloadType.Pointer:
return(elementType.MakePointerType());
case OverloadType.Array:
return(elementType.MakeArrayType());
case OverloadType.ByRef:
return(elementType.MakeByRefType());
//case OverloadType.Span:
// return typeof(Span<>).MakeGenericType(elementType);
default:
throw new Exception();
}
}
public static bool ActivateOverload(ref int overloadCount, ref OverloadType type, ref float overloadTime, ref bool ignoreWork, ref bool ignoreBossReward, ref bool ignoreDefaultOverload)
{
int time = (int)GlobalHistory.instance.GetCurrentTime();
if (CoreCh && time > 0)
{
int currentDay = PlayerModel.instance.GetDay() + 1;
int level = CreatureOverloadManager.instance.GetQliphothOverloadLevel();
overloadCount = (int)(currentDay / 4 * (1 + 0.25 * level));
ignoreBossReward = true;
if (ordealCoreCh)
{
overloadCount = 0;
}
}
return(true);
}
public static Parameter[] ChangePointerTypes(Parameter[] Params, OverloadType overload)
{
Parameter[] changedParams = new Parameter[Params.Length];
for (int i = 0; i < Params.Length; i++)
{
if (Params[i].Type.IsPointer)
{
var elemType = Params[i].Type.GetElementType();
changedParams[i] = new Parameter()
{
Name = Params[i].Name, Type = GetOverloadType(elemType, overload)
};
}
else
{
changedParams[i] = Params[i];
}
}
return(changedParams);
}
public static string GetOverloadSuffix(OverloadType overload)
{
switch (overload)
{
case OverloadType.Default:
return("");
case OverloadType.Pointer:
return("Ptr");
case OverloadType.Array:
return("Array");
case OverloadType.ByRef:
return("Ref");
//case OverloadType.Span:
// return "Span";
default:
throw new Exception();
}
}
public static void GenerateOverload(StringBuilder builder, ALSignature signature, OverloadType overload)
{
Parameter[] Params = ChangePointerTypes(signature.Params, overload);
string delegateName = signature.DelegateName + GetOverloadSuffix(overload);
string paramsString = GenerateParamString(Params, signature.OutOverloads);
string returnType = GetTypeName(signature.ReturnType, signature.OutOverloads);
string callString = GenerateCallParamString(Params, signature.OutOverloads);
bool @unsafe = overload == OverloadType.Pointer;
bool @private = overload == OverloadType.ByRef && signature.PrivateRefOverload;
builder.AppendLine(GenerateStaticFunction(signature.OverloadName, @private, delegateName, returnType, paramsString, callString, @unsafe));
builder.AppendLine(GenerateDelegateDeclaration(delegateName, "AL.ALCallingConvention", returnType, paramsString, @unsafe));
// FIXME: Entrypoint should be done better!!!
builder.AppendLine(GenerateDelegateField(delegateName, "LoadDelegate", signature.EntryPoint));
}
static void Main(string[] args)
{
// simple implimnetation of generic stack
var stack = new GenericStack <int>();
stack.Push(888);
stack.Push(999);
Console.WriteLine(stack.Pop());
Console.WriteLine(stack[0]);
//Generics can be used without explicitly specifying the type
//As long as type be inferred from the usage
int x = 88;
int y = 77;
GenericSwap.Swap(ref x, ref y);
Console.WriteLine(x);
Console.WriteLine(y);
//The type arguments for method 'GenericSwap.SwapInts<T>(ref int, ref int)'
//cannot be inferred from the usage. Try specifying the type arguments explicitly.
//GenericSwap.SwapInts(ref x, ref y);
decimal t1 = 323;
double t2 = 33;
// Since parameters implicitly specify types, T1 and T2 does not need to be explicitly defined
Console.WriteLine(MultipleTypeParams.Combine(t1, t2));
Console.WriteLine(MultipleTypeParams.CombineTypes(t1, t2));
var array = new int[3];
array[0] = 55;
Console.WriteLine(array[0]);
GenericDefaultValue.Zap(array);
Console.WriteLine(array[0]);
var accountList = new Account1[3];
accountList[0] = new Account1();
Console.WriteLine(accountList[0]);
GenericDefaultValue.Zap(accountList); // Will set value to NULL
Console.WriteLine(accountList[0] == null);
var account1 = new Account1(); //Account1 impliments both AccountFrozen and IAccountState
var account2 = new Account2(); //Account2 does not impliment IAccountState
new GenericMultiConstraints <Account1>().Deposit();
//The type 'GenericsBuilder.Account2' cannot be used as type parameter 'TState'
//in the generic type or method 'GenericMultiConstraints<TState>'.
//There is no implicit reference conversion from 'GenericsBuilder.Account2' to 'GenericsBuilder.IAccountState'.
//new GenericMultiConstraints<Account2>().Deposit();
GenericMethodWithConstraints.ProcessStruct <int>();
//The type 'string' must be a non-nullable value type in order to use it as parameter 'TKey'
//in the generic type or method 'GenericMethodWithConstraints.ProcessStruct<TKey>()'
//GenericMethodWithConstraints.ProcessStruct<string>();
// 'Max' is a generic method with IComaparable constraint
// All types passed into this method should impliment IComaparable<T>
// This allows the method to use 'CompareTo' method with the type parameter
var maxString = GenericMethodWithConstraints.Max("home1", "home2");
Console.WriteLine(maxString);
var maxInt = GenericMethodWithConstraints.Max(1, 2);
Console.WriteLine(maxInt);
var home1 = new Home()
{
Area = 500
};
var home2 = new Home()
{
Area = 200
};
var homeWithMaxArea = GenericMethodWithConstraints.Max(home1, home2);
Console.WriteLine(homeWithMaxArea.Area);
/*
*
* var students = new Students();
*
* Console.WriteLine(students[0].Name);
* Console.WriteLine(students[0].Age);
* Console.WriteLine(students[2].Name);
*/
//var dic = new Dictionary<int, int>();
// Generic types can be overloaded within the same namesapce based on the number of type arguments
var newOverloadedGenericType = new OverloadType <int>();
var newOverloadedGenericType2 = new OverloadType <int, string>();
var newOverloadedGenericType3 = new OverloadType <int, int, int>();
//Usig generic extension method with generic delegate to convert from one type to another
string number = "99";
var intNumber = number.ConvertToType(TypeConverter.ConvertStringToInt);
Console.WriteLine(intNumber);
// Array extension method with generic delegates to convert array type
string[] intArray = new string[] { "false", "true", "0", "1" };
bool[] resultArray = intArray.ConvertArrayToType(TypeConverter.ConvertStringToBool);
for (int i = 0; i < resultArray.Length; i++)
{
Console.WriteLine(resultArray[i]);
}
// RefTypeConstraintStruct is a generic struct with constraints
//that only takes 'reference' type as the type argument
var refTypeStruct1 = new RefTypeConstraintStruct <Student>();
var refTypeStruct2 = new RefTypeConstraintStruct <int[]>();
//GenericsBuilder.RefTypeConstraintStruct`1[GenericsBuilder.Student]
//GenericsBuilder.RefTypeConstraintStruct`1[System.Int32[]]
Console.WriteLine(refTypeStruct1.ToString());
Console.WriteLine(refTypeStruct2.ToString());
//The type 'int' must be a reference type in order to use it as parameter 'T' in the generic type or
//method 'RefTypeConstraintStruct<T>'
//var refTypeStruct3 = new RefTypeConstraintStruct<int>();
var valTypeConstraint1 = new ValueTypeConstraintClass <AccountType>();
//The type 'Student' must be a non-nullable value type in order to use it as parameter 'T'
//var valTypeConstraint2 = new ValueTypeConstraintClass<Student>();
// generic classes with constructor type constraints require a class that has
//implicit or explicit parameterless constructor
var ctorContraint1 = new ConstructorTypeConstraint <ClassWithParamlessCtor>();
//'ClassWithExplicitCtor' must be a non-abstract type with a public parameterless constructor in order to use it as parameter 'T'
//in the generic type or method 'ConstructorTypeConstraint<T>'
//var ctorContraint2 = new ConstructorTypeConstraint<ClassWithExplicitCtor>();
// type argument must be a class derived from abstract class 'Stream'
var stream1 = new ConversionTypeConstraint <FileStream>();
// Invalid argement violating conversion type constraint
//The type 'System.Text.StringBuilder' cannot be used as type parameter 'T'
//in the generic type or method 'ConversionTypeConstraint<T>'.
//There is no implicit reference conversion from 'System.Text.StringBuilder' to 'System.IO.Stream'
//var stream2 = new ConversionTypeConstraint<StringBuilder>();
var multiConvert = new ConversionTypeConstraint <FileStream, Stream>();
//use of unbound generic type without the use of arguments
Type type1 = typeof(UnboundType <>);
Console.WriteLine(type1.FullName); //GenericsBuilder.UnboundType`1
// comma added to specify that this is the unbound type with 2 type paramaeters
Type type2 = typeof(UnboundType <,>);
Console.WriteLine(type2.FullName); //GenericsBuilder.UnboundType`2
Type type3 = typeof(UnboundType <int, double>);
//GenericsBuilder.UnboundType`2
//[[System.Int32, System.Private.CoreLib, Version=4.0.0.0],
//[System.Double, System.Private.CoreLib, Version=4.0.0.0]
Console.WriteLine(type3.FullName);
var refAndStruct = new MultiConstraintsRef <ICusRefType, CusStruct>();
}
public DynamicSpawnZoneOverloadBlock(BinaryReader binaryReader)
{
this.overloadType = (OverloadType)binaryReader.ReadInt16();
this.padding = binaryReader.ReadBytes(2);
this.innerRadius = binaryReader.ReadSingle();
this.outerRadius = binaryReader.ReadSingle();
this.weight = binaryReader.ReadSingle();
}
