Example #1
0
        public UserSizeProvider()
        {
            provider              = GetProvider();
            provider.SizeChanged += Provider_SizeChanged;

            preferences.PropertyChanged += Preferences_PropertyChanged;
        }
Example #2
0
 public SockProvider(ISockRepository sockRepository, IMaterialProvider materialProvider, IThicknessProvider thicknessProvider, ISizeProvider sizeProvider)
 {
     _sockRepository    = sockRepository;
     _materialProvider  = materialProvider;
     _thicknessProvider = thicknessProvider;
     _sizeProvider      = sizeProvider;
 }
Example #3
0
        public Bullet(
            Entity source,
            ISizeProvider sizeProvider,
            TargetType targetType,
            float x              = 0,
            float y              = 0,
            float velX           = 0,
            float velY           = 0,
            float direction      = 0,
            int damage           = 1,
            int howManyCanDamage = 1) : base(x, y, velX, velY, howManyCanDamage, direction)
        {
            this.sizeProvider = sizeProvider;
            Source            = source;
            TargetType        = targetType;
            AlignDirectionByVelocity();

            Damage = damage;
            if (howManyCanDamage <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(howManyCanDamage) + " must be positive!");
            }
            Health       = howManyCanDamage;
            CollisionBox = new CollisionBox(this, 1, 1);
        }
Example #4
0
        public BagelEnemy(BagelType bagelType,
                          ISizeProvider sizeProvider = null,
                          IEntityAdder entityAdder   = null,
                          float x         = 0,
                          float y         = 0,
                          float velX      = 0,
                          float velY      = 0,
                          int health      = 1,
                          float direction = 0) :
            base(x, y, velX, velY, health, direction)
        {
            BagelType = bagelType;

            this.sizeProvider = sizeProvider;
            if (sizeProvider == null && bagelType == BagelType.Bouncing)
            {
                throw new ArgumentException("How I can bounce when there're no walls?");
            }

            this.entityAdder = entityAdder;
            if (entityAdder == null &&
                (bagelType == BagelType.Shooting ||
                 bagelType == BagelType.Clone ||
                 bagelType == BagelType.InvincibleClone))
            {
                throw new ArgumentException("I must add \"bullets\" somewhere!");
            }
            if (bagelType == BagelType.Clone ||
                bagelType == BagelType.InvincibleClone)
            {
                rand = new Random();
            }

            UpdateCollisionBox();
        }
Example #5
0
        internal override int?__InternalGetSize(ISizeProvider Context)
        {
            int MaxItemSize = 4;
            int Offset      = 0;

            foreach (var Item in Items)
            {
                int?Size = Item.CType.__InternalGetSize(Context);

                if (!Size.HasValue)
                {
                    return(null);
                }

                MaxItemSize = Math.Max(MaxItemSize, Size.Value);

                while ((Offset % Size) != 0)
                {
                    Offset++;
                }
                Offset += Size.Value;
            }

            while ((Offset % MaxItemSize) != 0)
            {
                Offset++;
            }

            return(Offset);
        }
Example #6
0
 internal override int?__InternalGetSize(ISizeProvider Context)
 {
     if (Context == null)
     {
         return(null);
     }
     return(Context.PointerSize);
 }
Example #7
0
        private async void Preferences_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName is nameof(IPreferencesSettingsService.ShowFolderSize))
            {
                await provider.ClearAsync();

                provider.SizeChanged -= Provider_SizeChanged;
                provider              = GetProvider();
                provider.SizeChanged += Provider_SizeChanged;
            }
        }
        public MonitorViewModel(ISizeProvider provider, INotifyService notifyService)
        {
            if (provider == null) throw new ArgumentNullException("provider");
            if (notifyService == null) throw new ArgumentNullException("notifyService");

            _provider = provider;
            _notifyService = notifyService;

            provider.SizeChanged += ProviderSizeChanged;

            GetSnapshot();
        }
Example #9
0
        internal override int?__InternalGetSize(ISizeProvider Context)
        {
            // TODO: Fake to get the higher size a pointer would get on x64.
            if (this.Type == null)
            {
                return(0);
            }
            if (this.Type.IsPointer)
            {
                return(8);
            }

            return(Marshal.SizeOf(this.Type));
        }
Example #10
0
 public Player(
     ISizeProvider sizeProvider,
     int x           = 0,
     int y           = 0,
     float velX      = 0,
     float velY      = 0,
     int health      = 1,
     float direction = 0,
     float speed     = 1) :
     base(x, y, velX, velY, health, direction)
 {
     this.sizeProvider  = sizeProvider;
     this.speed         = speed;
     verticalMovement   = 0;
     horizontalMovement = 0;
     TargetType         = TargetType.None;
     CollisionBox       = new CollisionBox(this, 64, 64);
 }
Example #11
0
        internal override int?__InternalGetSize(ISizeProvider Context)
        {
            switch (BasicType)
            {
            case CTypeBasic.Void: return(0);

            case CTypeBasic.Bool: return(1);

            case CTypeBasic.Char: return(1);

            case CTypeBasic.Short: return(2);

            case CTypeBasic.Int: return((LongCount < 2) ? 4 : 8);

            case CTypeBasic.Float: return(4);

            case CTypeBasic.Double: return(8);

            case CTypeBasic.ComplexType: return(ComplexType.GetSize(Context));

            default: throw(new NotImplementedException());
            }
        }
Example #12
0
 public int?GetSize(ISizeProvider Context)
 {
     return(CType.GetSize(Context));
 }
Example #13
0
 public int?GetSize(ISizeProvider Context)
 {
     return(__InternalGetSize(Context));
 }
Example #14
0
 abstract internal int?__InternalGetSize(ISizeProvider Context);
Example #15
0
 public int? GetSize(ISizeProvider Context)
 {
     return CType.GetSize(Context);
 }
Example #16
0
 internal override int?__InternalGetSize(ISizeProvider Context)
 {
     throw new NotImplementedException();
 }
Example #17
0
 internal override int?__InternalGetSize(ISizeProvider Context)
 {
     return(Context.PointerSize);
 }
 public BackgroundDownloader(ISizeProvider sizeProvider,
                             ILogger logger)
 {
     this.sizeProvider = sizeProvider;
     this.logger       = logger;
 }
Example #19
0
        public EnemyGenerator(IEntityAdder entityAdder, ISizeProvider sizeProvider)
        {
            this.entityAdder  = entityAdder;
            this.sizeProvider = sizeProvider;
            rand = new Random();
            enemyWaveGenerators = new List <Action>
            {
                () =>
                {
                    //4-way bounce attack
                    const int health = 3;
                    var       farX   = sizeProvider.Width - 40;
                    var       farY   = sizeProvider.Height - 40;
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.Bouncing, this.sizeProvider, null, 40, 40, 5, 5, health));
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.Bouncing, this.sizeProvider, null, 40, farY, 5, -5, health));

                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.Bouncing, this.sizeProvider, null, farX, 40, -5, 5, health));
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.Bouncing, this.sizeProvider, null, farX, farY, -5, -5, health));
                },
                () =>
                {
                    //clone attack
                    const int health = 10;
                    var       farX   = sizeProvider.Width - 40;
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.Clone, this.sizeProvider, this.entityAdder,
                                       40, 40, 0, 0, health));
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.Clone, this.sizeProvider, this.entityAdder,
                                       farX, 40, 0, 0, health));
                }, () =>
                {
                    //healing attack
                    const int health = 10;
                    var       farX   = sizeProvider.Width - 40;
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.Healing, this.sizeProvider, this.entityAdder,
                                       40, 40, 0, 0, health));
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.InvincibleClone, this.sizeProvider, this.entityAdder,
                                       farX, 40, 0, 0, health));
                },
                () =>
                {
                    //inv clone attack
                    const int health = 10;
                    var       farX   = sizeProvider.Width - 40;
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.InvincibleClone, this.sizeProvider, this.entityAdder,
                                       40, 40, 0, 0, health));
                    entityAdder.AddEntity(
                        new BagelEnemy(BagelType.InvincibleClone, this.sizeProvider, this.entityAdder,
                                       farX, 40, 0, 0, health));
                },
                () =>
                {
                    const int health = 1;
                    for (var i = 0; i > -500; i -= 64)
                    {
                        entityAdder.AddEntity(
                            new BagelEnemy(BagelType.Shooting, this.sizeProvider, this.entityAdder,
                                           i, i, 10, 3, health));
                        entityAdder.AddEntity(
                            new BagelEnemy(BagelType.Shooting, this.sizeProvider, this.entityAdder,
                                           sizeProvider.Width - i, i, -10, 3, health));
                    }
                },
                () =>
                {
                    const int health = 2;
                    for (var i = 0; i > -500; i -= 64)
                    {
                        entityAdder.AddEntity(
                            new BagelEnemy(BagelType.Basic, this.sizeProvider, this.entityAdder,
                                           i, i, 5, 5, health));
                        entityAdder.AddEntity(
                            new BagelEnemy(BagelType.Basic, this.sizeProvider, this.entityAdder,
                                           sizeProvider.Width - i, i, -5, 5, health));
                    }
                },
                () =>
                {
                    const int health = 2;
                    for (var i = 40; i < 700; i += 64)
                    {
                        entityAdder.AddEntity(
                            new BagelEnemy(BagelType.Basic, this.sizeProvider, this.entityAdder,
                                           i / 2, i - 1000, 0, 5, health));
                        entityAdder.AddEntity(
                            new BagelEnemy(BagelType.Basic, this.sizeProvider, this.entityAdder,
                                           sizeProvider.Width - i / 2, i - 1000, 0, 5, health));
                    }
                }
            };
        }
Example #20
0
 public GenericAnsiConsole(TextWriter writer, ISizeProvider interOpt)
 {
     Writer         = writer;
     _consoleWriter = false;
     _interOpt      = interOpt;
 }