球随机布局

实现球随机布局

最近碰到一个需求，需要在界面上随机出一些大小、颜色、位置随机的球（圆形按钮），并能够保证视觉效果好看，并且可以切换上一屏和下一屏附带动画，针对该需求想了很多方法，写该篇文章记录下来

效果如下图：


代码地址：GWCircleLayoutBall

分析

拿到上面UI图后，首先分析UI的需求，有以下规律：

  1. 球有随机一共5种大小
  2. 球颜色各不相同
  3. 最多有两个球相交，并且小部分相交
  4. 有一个球在靠近中心点位置，并大小偏大
  5. 切换到下一屏时重新随机不同位置的球，上一屏球移出动画
  6. 切换到上一屏时，当前屏球透明消失，上一屏从屏外移回到以前的位置

第一个想到的是使用UICollectionView实现圆形布局，但是除中心球外，外面的球并不在圆上面，而且四周的球可能离相同圆弧很远。根据所有的布局和代码问题都应该抽象成一个数学问题的思路，最后发现要保证UI的协调和好看，需要保证球的随机错落分布的同时保证球整体是均匀分布的。
最后得到一个思路，从中心点出发，在屏幕上绘制圆形轨道，第一个球在第一个小圆的轨道上偏移，随后的球在之后的轨道上随机均匀分布；其次为了让球随机分布，看不出在同一个圆的轨道上，应该给每一个球一个中心点偏移量。

大概如下图：


为了保证随机的同时均匀分布，则应该圆轨道上第一个球随机位置，然后同一个圆上面其它位置球相对在一定范围内随机。该圆形轨道的下一个轨道上，则根据该轨道第一个球进行一定范围内便宜，就像是内圈的球组成一个三角形，下一个轨道上也组成一个三角形，形成一定偏移。
具体实现思路：

  1. 在屏幕上计算圆形轨道，存储圆形轨道半径数组
  2. 球随机位置通过随机角度来实现，随机一个角度，通过圆形点和角度计算出球中心的位置，对中心位置给一个范围内的随机偏移
  3. 第二个球也随机一个角度，然后随机一个大小，放到第二个轨道上。
  4. 大于第一层并且不是该层第一个球则获取前一个球的角度，计算平均角度值（360 / 球个数）然后随机一个角度偏移量，计算出该球位置
  5. 大于第二层轨道的球，为了保证不与前一层轨道的球重叠，则该轨道第一个球先获取前一层第一个球的角度，在该角度基础上随机一定范围的角度偏移

这其中涉及到两个问题：

  1. iOS中随机一个范围内的值
  2. 根据中心点和角度计算坐标点

上面这两个问题，网上都有现成的代码。
下面直接上代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/**
 在一定范围内生成随机数
 @param from 起始值
 @param to 结束值
 @return 随机数
 */
- (int)getRandomNumber:(int)from to:(int)to
{
    return (int)(from + (arc4random() % (to - from + 1))); //+1,result is [from to]; else is [from, to)!!!!!!!
}

/**
 --------------------------------------------------------------
 功能说明
 --------------------------------------------------------------
 根据IOS视图中圆组件的中心点(x,y)、半径(r)、圆周上某一点与圆心的角度这3个
 条件来计算出该圆周某一点在IOS中的坐标(x2,y2)。
 
 注意：
 （1）IOS坐标体系与数学坐标体系有差别，因此不能完全采用数学计算公式。
 （2）数学计算公式：
 x2=x+r*cos(角度值*PI/180)
 y2=y+r*sin(角度值*PI/180)
 （3）IOS中计算公式：
 x2=x+r*cos(角度值*PI/180)
 y2=y-r*sin(角度值*PI/180)
 
 --------------------------------------------------------------
 参数说明
 --------------------------------------------------------------
 @param (CGPoint) center
 
 圆圈在IOS视图中的中心坐标，即该圆视图的center属性
 
 @param (CGFloat) angle
 角度值，是0～360之间的值。
 注意：
 （1）请使用下面坐标图形进行理解。
 （2）角度是逆时针转的，从x轴中心(0,0)往右是0度角（或360度角），往左是180度角，往上是90度角，往下是270度角。
 
 (y)
 ^
 |
 |
 |
 |
 -----------------> (x)
 |(0,0)
 |
 |
 |
 
 @param (CGFloat) radius
 圆周半径
 */
#pragma mark 计算圆圈上点在IOS系统中的坐标
- (CGPoint)calcCircleCoordinateWithCenter:(CGPoint) center  andWithAngle : (CGFloat) angle andWithRadius: (CGFloat) radius{
    CGFloat x2 = ceilf(radius*cosf(angle*M_PI/180));
    CGFloat y2 = ceilf(radius*sinf(angle*M_PI/180));
    return CGPointMake(center.x+x2, center.y-y2);
}

首先定一个Model类来保存球即圆形按钮的布局相关参数，其中出现位置和移动位置后面做交互动画用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@interface CircleButtonModel : NSObject
/*! @brief 颜色 */
@property(nonatomic, strong) UIColor *color;
/*! @brief 大小 */
@property(nonatomic, assign) CGSize size;
/*! @brief 当前的位置 */
@property(nonatomic, assign) CGPoint center;
/*! @brief 出现的位置 */
@property(nonatomic, assign) CGPoint fromCenter;
/*! @brief 移动到的位置 */
@property(nonatomic, assign) CGPoint toCenter;
/*! @brief 角度 */
@property(nonatomic, assign) int angle;
/*! @brief id */
@property(nonatomic, copy) NSString *scene_id;
/*! @brief 是否被点击 */
@property(nonatomic, assign, getter=isClicked) BOOL clicked;
@end

核心是如何去随机球的位置，要移出屏幕的位置等，球的位置由球的下标计算出球所在的圆弧，然后根据半径，随机的角度，中心偏移量计算出位置坐标；移出的坐标则是通过计算球中心所在的象限，斜着飞出屏幕。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
- (NSArray *)createButtons{
    //一屏球的个数限定最大为7，最小为4, 随机一个数
    NSInteger num = [self getRandomNumber:4 to:7];
    CGPoint center = self.center;
    NSMutableArray *buttons = [NSMutableArray arrayWithCapacity:num];
    NSMutableArray *circles = [NSMutableArray arrayWithCapacity:num];
    //用来记录第一个球是大球还是中球
    int maxIndex = 0;
    int maxCount[3] = {1, 3, 3};
    int currentCount[3] = {0, 0, 0};
    for (NSInteger j = 0; j < num; j++) {
        //1.处理球的颜色
        CircleButtonModel *circleButtonModel = [CircleButtonModel new];
        [circles addObject:circleButtonModel];
        //1.1随机一个颜色
        int R = (arc4random() % 256);
        int G = (arc4random() % 256);
        int B = (arc4random() % 256);
        UIColor *color = [UIColor colorWithRed:R/255.0 green:G/255.0 blue:B/255.0 alpha:1];
        circleButtonModel.color = color;
        //2.处理球的大小
        //2.1第一个默认大球，第二个默认中球，之后随机大小
        if (0 == j) {
            circleButtonModel.size = buttonSizeArray[1];
        }else if(1 == j){
            circleButtonModel.size = buttonSizeArray[2];
        }else{
            int sizeIndex = [self getRandomNumber:2 to:4];
            circleButtonModel.size = buttonSizeArray[sizeIndex];
        }
        //2.处理球的位置
        //2.1随机球圆心在圆弧上的一个偏移量
        int offset = [self getRandomNumber:-10 to:10];
        //2.2随机一个角度偏移量
        int angleOffset = [self getRandomNumber:-10 to:10];
        //        offset = 0;
        //            CGPoint newCenter = CGPointMake(center.x - offset, center.y - offset);
        CGPoint newCenter = center;
        if (0 == maxIndex) {
            int angle = [self getRandomNumber:0 to:360];
            circleButtonModel.angle = angle;
            circleButtonModel.center = [self calcCircleCoordinateWithCenter:newCenter andWithAngle:angle andWithRadius:(radiusArray[maxIndex] + offset)];
        }else if(1 == maxIndex){
            if (0 == currentCount[maxIndex]) {
                int angle = [self getRandomNumber:0 to:360];
                circleButtonModel.angle = angle;
                circleButtonModel.center = [self calcCircleCoordinateWithCenter:newCenter andWithAngle:angle andWithRadius:(radiusArray[maxIndex] + offset)];
            }else{
                CircleButtonModel *preCircleButtonModel = circles[j - 1];
                int angle = 360 / maxCount[maxIndex] + angleOffset + preCircleButtonModel.angle;
                angle = angle > 360 ? (angle - 360) : angle;
                circleButtonModel.angle = angle;
                circleButtonModel.center = [self calcCircleCoordinateWithCenter:newCenter andWithAngle:angle andWithRadius:(radiusArray[maxIndex] + offset)];
            }
        }else{
            if (0 == currentCount[maxIndex]) {
                int index = (int)(j - maxCount[maxIndex -1]);
                CircleButtonModel *preCircleButtonModel = circles[index];
                int angle = [self getRandomNumber:60 to:90] + preCircleButtonModel.angle;
                angle = angle > 360 ? (angle - 360) : angle;
                circleButtonModel.angle = angle;
                circleButtonModel.center = [self calcCircleCoordinateWithCenter:newCenter andWithAngle:angle andWithRadius:(radiusArray[maxIndex] + offset)];
            }else{
                CircleButtonModel *preCircleButtonModel = circles[j - 1];
                int angle = 360 / maxCount[maxIndex] + angleOffset + preCircleButtonModel.angle;
                angle = angle > 360 ? (angle - 360) : angle;
                circleButtonModel.angle = angle;
                circleButtonModel.center = [self calcCircleCoordinateWithCenter:newCenter andWithAngle:angle andWithRadius:(radiusArray[maxIndex] + offset)];
            }
        }
        int currentNum  = currentCount[maxIndex] + 1;
        if (currentNum >= maxCount[maxIndex]) {
            maxIndex++;
        }else{
            currentCount[maxIndex] = currentNum;
        }
        //3.处理球的离开屏幕动画的位置
        int quadrant = ceil((circleButtonModel.angle / 90) % 4);
        int toX = 0;
        int toY = 0;
        int toOffset = [self getRandomNumber:60 to:120];
        switch (quadrant) {
            case 0:
                toX = self.view.frame.size.width + circleButtonModel.size.width * 0.5;
                toY = circleButtonModel.center.y - toOffset;
                break;
            case 1:
                toX = -circleButtonModel.size.width * 0.5;
                toY = circleButtonModel.center.y - toOffset;
                break;
            case 2:
                toX = -circleButtonModel.size.width * 0.5;
                toY = circleButtonModel.center.y + toOffset;
                break;
            case 3:
                toX = self.view.frame.size.width + circleButtonModel.size.width * 0.5;
                toY = circleButtonModel.center.y + toOffset;
                break;
            default:
                toX = self.view.frame.size.width + circleButtonModel.size.width * 0.5;
                toY = circleButtonModel.center.y - toOffset;
                break;
        }
        circleButtonModel.toCenter = CGPointMake(toX, toY);
        //4.创建按钮
        CGRect frame = CGRectZero;
        frame.size = circleButtonModel.size;
        BMRoundButton *button = [[BMRoundButton alloc] initWithFrame:frame];
        [button setTitle:[NSString stringWithFormat:@"按钮%ld", j] forState:UIControlStateNormal];
        button.backgroundColor = circleButtonModel.color;
        button.center = circleButtonModel.center;
        button.buttonModel = circleButtonModel;
        //            [self.view addSubview:button];
        
        //            int cornerRadius = frame.size.width * 0.5;
        //            UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:button.bounds byRoundingCorners:UIRectCornerAllCorners cornerRadii:CGSizeMake(cornerRadius, cornerRadius)];
        //            CAShapeLayer *layer = CAShapeLayer.new;
        //            layer.path = path.CGPath;
        //            layer.frame = button.bounds;
        //            button.layer.mask = layer;
        //        [self animationScaleOnceWithView:button];
        //            [self animationUpDownWithView:button];
        
        [button addTarget:self action:@selector(buttonOnClicked:) forControlEvents:UIControlEventTouchUpInside];
        [buttons addObject:button];
    }
    return [buttons copy];
}

动画

在随机球的基础上加上随机上下的动画，类似漂浮的动画，让界面更好看。
思路是：让球的中心在一个随机的范围内上下移动，并且每个球的上下动画随机，形成错落有致的视觉效应。
代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/**
 添加上下漂浮动画
 @param view 要加动画的View
 */
- (void)animationUpDownWithView:(UIView *)view
{
    CALayer *viewLayer = view.layer;
    CGPoint position = viewLayer.position;
    CGPoint fromPoint = CGPointMake(position.x, position.y);
    CGPoint toPoint = CGPointZero;
    
    uint32_t typeInt = arc4random() % 100;
    CGFloat distanceFloat = 0.0;
    //随机0 - 3之前的一个随机数
    while (distanceFloat == 0) {
        distanceFloat = (3 + (int)(arc4random() % (9 - 7 + 1))) * 100.0 / 101.0;
    }
    //随机上或者下
    if (typeInt % 2 == 0) {
        toPoint = CGPointMake(position.x, position.y - distanceFloat);
    } else {
        toPoint = CGPointMake(position.x, position.y + distanceFloat);
    }
    
    CABasicAnimation *animation = [CABasicAnimation animationWithKeyPath:@"position"];
    animation.removedOnCompletion = NO;
    animation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
    animation.fromValue = [NSValue valueWithCGPoint:fromPoint];
    animation.toValue = [NSValue valueWithCGPoint:toPoint];
    animation.autoreverses = YES;
    //随机动画的总时长1.2 + x / 31
    CGFloat durationFloat = 0.0;
    while (durationFloat == 0.0) {
        durationFloat = 1.2 + (int)(arc4random() % (100 - 70 + 1)) / 31.0;
    }
    [animation setDuration:durationFloat];
    [animation setRepeatCount:MAXFLOAT];
    
    [viewLayer addAnimation:animation forKey:@"upAndDown"];
    //添加动画围绕圆形轨迹运动，视觉效果不太好
    //    CAKeyframeAnimation *keyFrameAnimation = [CAKeyframeAnimation animationWithKeyPath:@"position"];
    //    keyFrameAnimation.removedOnCompletion = NO;
    //    keyFrameAnimation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
    ////    keyFrameAnimation.autoreverses = YES;
    //    UIBezierPath *path = [[UIBezierPath alloc] init];
    //    [path addArcWithCenter:view.center radius:2 startAngle:0 endAngle:2*M_PI clockwise:YES];
    //    keyFrameAnimation.path = path.CGPath;
    //    keyFrameAnimation.beginTime = CACurrentMediaTime() + [self getRandomNumber:0 to:10] * 1.0 / 20.0;
    //    [keyFrameAnimation setDuration:4];
    //    [keyFrameAnimation setRepeatCount:MAXFLOAT];
    //    [viewLayer addAnimation:keyFrameAnimation forKey:@"rotation"];
}

交互动画

交互动画主要是切下一屏和切上一屏
切下一屏动画组成

  1. 点击的球逐渐变小和变透明然后消失
  2. 根据之前计算的球要移出屏幕的坐标分别做位移动画
  3. 下一屏的球从点击的球中心点出现，做大小和位移动画
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
- (void)showNextButtons{
    NSArray *currentButtons =  self.buttonsArray[self.currentLevel];
    NSArray *nextButtons = [self createButtons];
    //移出屏幕动画
    for (BMRoundButton *button in currentButtons) {
        CircleButtonModel *circleButtonModel = button.buttonModel;
        if (!circleButtonModel.clicked) {
            CABasicAnimation *animation = [CABasicAnimation animationWithKeyPath:@"position"];
            animation.fromValue = [NSValue valueWithCGPoint:button.center];
            animation.toValue = [NSValue valueWithCGPoint:circleButtonModel.toCenter];
            animation.duration = 1.0;
            animation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
            animation.fillMode = kCAFillModeForwards;
            animation.removedOnCompletion = NO;
            [button.layer addAnimation:animation forKey:@"moveOut"];
            //            [button removeFromSuperview];
        }else{
            //点击button的动画
            CABasicAnimation *scaleAnimation = [CABasicAnimation animationWithKeyPath:@"transform.scale"];
            scaleAnimation.fromValue = @(1.0);
            scaleAnimation.toValue = @(0.3);
            //        positionAnimation.duration = 1.0;
            scaleAnimation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
            scaleAnimation.fillMode = kCAFillModeForwards;
            scaleAnimation.removedOnCompletion = NO;
            CABasicAnimation *opacityAnimation = [CABasicAnimation animationWithKeyPath:@"opacity"];
            opacityAnimation.fromValue = @(1.0);
            opacityAnimation.toValue = @(0.0);
            //        opacityAnimation.duration = 1.0;
            opacityAnimation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
            opacityAnimation.fillMode = kCAFillModeForwards;
            opacityAnimation.removedOnCompletion = NO;
            CAAnimationGroup *animationGroup = [CAAnimationGroup animation];
            animationGroup.animations = @[scaleAnimation, opacityAnimation];
            animationGroup.duration = 1.0;
            animationGroup.fillMode = kCAFillModeForwards;
            animationGroup.removedOnCompletion = NO;
            [button.layer addAnimation:animationGroup forKey:@"clicked"];
            //    self.clickedButton.transform = CGAffineTransformIdentity;
            //    [UIView animateWithDuration:1.0 animations:^{
            //        self.clickedButton.transform = CGAffineTransformMakeScale(0.3, 0.3);
            //        self.clickedButton.alpha = 0.0;
            //    } completion:^(BOOL finished) {
            //        self.clickedButton.alpha = 0.0;
            //    }];
        }
    }
    //保存新创建的buttons
    self.currentLevel++;
    [self addButtonsToArray:nextButtons];
    //出现动画
    for (BMRoundButton *button in nextButtons) {
        CircleButtonModel *circleButtonModel = button.buttonModel;
        CABasicAnimation *positionAnimation = [CABasicAnimation animationWithKeyPath:@"position"];
        positionAnimation.fromValue = [NSValue valueWithCGPoint:self.clickedButton.center];
        positionAnimation.toValue = [NSValue valueWithCGPoint:circleButtonModel.center];
        //        positionAnimation.duration = 1.0;
        positionAnimation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
        positionAnimation.fillMode = kCAFillModeForwards;
        positionAnimation.removedOnCompletion = NO;
        CABasicAnimation *opacityAnimation = [CABasicAnimation animationWithKeyPath:@"opacity"];
        opacityAnimation.fromValue = @(0.0);
        opacityAnimation.toValue = @(1.0);
        //        opacityAnimation.duration = 1.0;
        opacityAnimation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
        opacityAnimation.fillMode = kCAFillModeForwards;
        opacityAnimation.removedOnCompletion = NO;
        CAAnimationGroup *animationGroup = [CAAnimationGroup animation];
        animationGroup.animations = @[positionAnimation, opacityAnimation];
        animationGroup.duration = 1.0;
        [button.layer addAnimation:animationGroup forKey:@"moveIn"];
    }
    
}

切上一屏动画组成

  1. 点击的球逐渐变小和变透明然后消失
  2. 当前屏的球透明变小消失
  3. 上一屏的球从屏外移回之前的位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
- (void)showPreButtons{
    NSInteger preLevel = self.currentLevel - 1;
    if (preLevel < 0) return;
    NSArray *currentButtons =  self.buttonsArray[self.currentLevel];
    NSArray *preButtons = self.buttonsArray[preLevel];
    //移除动画
    for (BMRoundButton *button in currentButtons) {
        button.transform = CGAffineTransformIdentity;
        [UIView animateWithDuration:0.5 animations:^{
            button.transform = CGAffineTransformMakeScale(0.3, 0.3);
            button.alpha = 0.0;
        } completion:^(BOOL finished) {
            [button removeFromSuperview];
        }];
    }
    //移回屏幕动画
    for (BMRoundButton *button in preButtons) {
        CircleButtonModel *circleButtonModel = button.buttonModel;
        //如果按钮是之前点选的，则说明只用做形变动画
        if (!circleButtonModel.clicked) {
            CABasicAnimation *animation = [CABasicAnimation animationWithKeyPath:@"position"];
            animation.fromValue = [NSValue valueWithCGPoint:circleButtonModel.toCenter];
            animation.toValue = [NSValue valueWithCGPoint:button.center];
            animation.duration = 1.0;
            animation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
            animation.fillMode = kCAFillModeForwards;
            animation.removedOnCompletion = NO;
            [button.layer addAnimation:animation forKey:@"moveBack"];
        }else{
            //点击button的动画
            CABasicAnimation *scaleAnimation = [CABasicAnimation animationWithKeyPath:@"transform.scale"];
            scaleAnimation.fromValue = @(0.0);
            scaleAnimation.toValue = @(1.0);
            //        positionAnimation.duration = 1.0;
            scaleAnimation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
            scaleAnimation.fillMode = kCAFillModeForwards;
            scaleAnimation.removedOnCompletion = NO;
            CABasicAnimation *opacityAnimation = [CABasicAnimation animationWithKeyPath:@"opacity"];
            opacityAnimation.fromValue = @(0.0);
            opacityAnimation.toValue = @(1.0);
            //        opacityAnimation.duration = 1.0;
            opacityAnimation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];
            opacityAnimation.fillMode = kCAFillModeForwards;
            opacityAnimation.removedOnCompletion = NO;
            CAAnimationGroup *animationGroup = [CAAnimationGroup animation];
            animationGroup.animations = @[scaleAnimation, opacityAnimation];
            animationGroup.duration = 1.0;
            animationGroup.fillMode = kCAFillModeForwards;
            animationGroup.removedOnCompletion = NO;
            [button.layer addAnimation:animationGroup forKey:@"clicked"];
//            button.transform = CGAffineTransformMakeScale(0.3, 0.3);
//            [UIView animateWithDuration:1.0 animations:^{
//                self.clickedButton.transform = CGAffineTransformIdentity;
//                self.clickedButton.alpha = 1.0;
//            } completion:^(BOOL finished) {
//                self.clickedButton.alpha = 1.0;
//            }];
        }
    }
    //移除操作

    [self deleteButtons];
}

- (void)deleteButtons{
    NSMutableArray *arrayM = [NSMutableArray arrayWithArray:self.buttonsArray];
    [arrayM removeLastObject];
    self.currentLevel--;
    self.buttonsArray = [arrayM copy];
}

这个UI和之前做的UI布局方式不太相同，
运用了很多数学只是和大量动画，数学在编程中真的非常重要。

赏

谢谢你请我喝咖啡

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

iOS攻城狮一枚<br><br>热爱coding，不断迭代不断成长