public DamageEventArgument(GameEventArgument args, GameObject _invokee, EnviromentFrame _frame,
                            double _amount,
                            DamageType _damageType,
                            bool _trueDamage = false)
     : base(args, _invokee, _frame)
 {
     SetValues(_amount, _damageType, _trueDamage);
 }
 public DamageEventArgument(
     EnviromentEventArgument args,
     GameObject _invokee,
     GameObject[] _targets,
     EnviromentFrame _frame,
     DamageAttribute _damageAttribute)
     : base(args.LocationObjectBearing, _invokee, _targets, args.Focuser, _frame)
 {
     DamageAttribute = _damageAttribute;
 }
 public DamageEventArgument(
     EnviromentEventArgument args,
     GameObject _invokee,
     GameObject[] _targets,
     EnviromentFrame _frame,
     double _amount,
     DamageType _damageType,
     bool _trueDamage = false)
     : base(args.LocationObjectBearing, _invokee, _targets, args.Focuser, _frame)
 {
     SetValues(_amount, _damageType, _trueDamage);
 }
Example #4
0
        public static string[] Register(EnviromentFrame env, object instanceOfImplementation)
        {
            const BindingFlags methodFlags = BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.Instance;
            var type = instanceOfImplementation.GetType();

            var descriptors = new List <MethodDescriptors>();

            foreach (var interfaceType in type.GetInterfaces()
                     .Where(t => t.GetCustomAttributes(typeof(EnviromentAttribute), false).Any()))
            {
                var envAtt = (EnviromentAttribute)interfaceType.GetCustomAttributes(typeof(EnviromentAttribute), true)
                             .FirstOrDefault();
                foreach (var interfaceMethodInfo in interfaceType.GetMethods(methodFlags))
                {
                    var implMethod = type.GetMethod(interfaceMethodInfo.Name, methodFlags);

                    if (implMethod == null)
                    {
                        continue;
                    }

                    descriptors.Add(new MethodDescriptors()
                    {
                        MethodName = implMethod.Name,
                        DefineName =
                            String.IsNullOrWhiteSpace(envAtt.EnviromentName)
                                ? implMethod.Name
                                : $"{envAtt.EnviromentName}:{implMethod.Name}",
                        Arguments  = implMethod.GetParameters(),
                        ReturnType = implMethod.ReturnType
                    });
                }

                var instantName   = $"{type.Name}_ClassRegistrator";
                var nameSpaceName = "Ogam3.Lsp.Generators";
                var codeRoot      = GenerateProxyClass(type, descriptors, nameSpaceName, instantName);

                //var code = CreateSrc(codeRoot); // TODO debug

                var compiler = CodeDomProvider.CreateProvider("CSharp");

                var DOMref =
                    AppDomain.CurrentDomain.GetAssemblies()
                    .Where(obj => !obj.IsDynamic)
                    .Select(obj => obj.Location)
                    .ToList();

                var currentAssembly = Assembly.GetExecutingAssembly();
                DOMref.Add(currentAssembly.Location);

                DOMref.Add(type.Assembly.Location);

                DOMref.AddRange(GetAssemblyFiles(type.Assembly));

                DOMref = DOMref.Distinct().ToList();

                var compilerParams = new CompilerParameters(DOMref.ToArray());
                compilerParams.GenerateInMemory        = true;
                compilerParams.GenerateExecutable      = false;
                compilerParams.IncludeDebugInformation = false;

                var cr = compiler.CompileAssemblyFromDom(compilerParams, codeRoot);

                foreach (var ce in cr.Errors)
                {
                    throw new Exception(ce.ToString());
                }

                var callerType = cr.CompiledAssembly.GetType($"{nameSpaceName}.{instantName}");

                Activator.CreateInstance(callerType, instanceOfImplementation, env);
            }

            return(GetAllNames(descriptors.ToArray()));
        }