作者：薛萌

演示效果

happyZ.gif

代码

  1. # 在 JavaScript 编程界面中，将此代码复制进去即可。
  3. class Vec2 {
  4.     x : number
  5.     y : number
  6.     constructor(x : number, y : number) {
  7.         this.x = x
  8.         this.y = y
  9.     }
  11.     Length() : number {
  12.         return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2))
  13.     }
  15.     Normalize() {
  16.         let s = this.Length()
  17.         if(s != 0) {
  18.             this.x = this.x / s
  19.             this.y = this.y / s
  20.         }
  21.     }
  23.     GetNormalize() : Vec2 {
  24.         let v = new Vec2(this.x, this.y)
  25.         v.Normalize()
  26.         return v
  27.     }
  29.     Add(rhs : Vec2) : Vec2 {
  30.         let x = this.x + rhs.x
  31.         let y = this.y + rhs.y
  32.         return new Vec2(x, y)
  33.     }
  35.     Mul(n : number) : Vec2 {
  36.         let x = this.x * n
  37.         let y = this.y * n
  38.         return new Vec2(x, y)
  39.     }
  40. }
  42. function ToLeft(a : Vec2, b : Vec2, p : Vec2 )
  43. {
  44.     // | a.x a.y 1 |
  45.     // | b.x b.y 1 |
  46.     // | p.x p.y 1 |
  47.     return a.x * b.y + b.x * p.y + p.x * a.y - a.y * b.x - b.y * p.x - p.y * a.x > 0.0;
  48. }
  50. let w = scene.screenWidth()
  51. let h = scene.screenHeight()
  52. let block_size = 10
  53. let row = 4
  54. let col = 16
  56. enum ItemType {
  57.     None = 0,
  58.     Green = 2,
  59.     Yellow = 3,
  60.     Red = 4,
  61.     Purple = 5
  62. }
  64. enum BlockType {
  65.     None   = 0,
  66.     Red    = 1,
  67.     Green  = 2,
  68.     Yellow = 3,
  69.     Purple = 4,
  70.     Brown  = 5
  71. }
  73. enum CollisionEdge {
  74.     None   = 0,
  75.     Top    = 1,
  76.     Bottom = 2,
  77.     Left   = 3,
  78.     Right  = 4
  79. }
  81. let Blocks : number[][] = [
  82.     [3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3],
  83.     [4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4],
  84.     [5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5],
  85.     [1, 2, 3, 4, 5, 4, 3, 2, 2, 3, 4, 5, 4, 3, 2, 1],
  86.     [1, 2, 3, 4, 5, 4, 3, 1, 1, 3, 4, 5, 4, 3, 2, 1],
  87. ]
  89. class Platform {
  90.     platform : Sprite
  91.     x : number
  92.     y : number
  93.     constructor(x : number, y : number) {
  94.         this.x = x
  95.         this.y = y
  96.         this.platform = sprites.create(assets.image`platform`, SpriteKind.Player)
  97.         this.platform.setPosition(this.x, this.y)
  98.         this.platform.setStayInScreen(true)
  99.         controller.moveSprite(this.platform, 80, 0)
  100.     }
  101. }
  103. class Ball {
  104.     ball : Sprite
  105.     speed : number
  106.     constructor(x : number, y : number, dir : Vec2) {
  107.         this.speed = 20
  108.         this.ball = sprites.create(assets.image`ball`, SpriteKind.Projectile)
  109.         this.ball.setPosition(x, y)
  110.         this.ball.setStayInScreen(true)
  111.         this.ball.setBounceOnWall(true)
  112.         dir.Normalize()
  113.         this.SetVelocity(dir)
  114.     }
  116.     GetDir() : Vec2 {
  117.         let dir = new Vec2(this.ball.vx, this.ball.vy)
  118.         dir.Normalize()
  119.         return dir
  120.     }
  122.     SpeedUp(p : number) {
  123.         this.speed += this.speed * p
  124.         this.SetVelocity(this.GetDir())
  125.     }
  127.     SetVelocity(dir : Vec2) {
  128.         this.ball.setVelocity(dir.x * this.speed, dir.y * this.speed)
  129.     }
  131.     GetPos() : Vec2 {
  132.         return new Vec2(this.ball.x, this.ball.y)
  133.     }
  134. }
  136. class MyBlock {
  137.     x : number
  138.     y : number
  139.     block : Sprite
  140.     px : number
  141.     py : number
  142.     HP : number
  143.     constructor(x : number, y : number, blockType : number) {
  144.         this.HP = blockType
  145.         this.x = x
  146.         this.y = y
  147.         this.CreateBlockByType(blockType)
  148.         this.px = this.x * block_size + block_size * 0.5
  149.         this.py = this.y * block_size + block_size * 0.5
  150.     }
  152.     CreateBlockByType(blockType : number) {
  153.         if(blockType == 1) {
  154.             this.block = sprites.create(assets.image`red_block`, SpriteKind.Enemy)
  155.         } else if(blockType == 2) {
  156.             this.block = sprites.create(assets.image`green_block`, SpriteKind.Enemy)
  157.         } else if(blockType == 3) {
  158.             this.block = sprites.create(assets.image`yellow_block`, SpriteKind.Enemy)
  159.         } else if(blockType == 4) {
  160.             this.block = sprites.create(assets.image`purple_block`, SpriteKind.Enemy)
  161.         } else if(blockType == 5) {
  162.             this.block = sprites.create(assets.image`brown_block`, SpriteKind.Enemy)
  163.         }
  164.     }
  166.     BeBreakOut() : boolean {
  167.         --this.HP
  168.         if(this.HP == 0) {
  169.             music.bigCrash.play()
  170.             return true
  171.         }
  172.         music.smallCrash.play()
  173.         this.block.destroy()
  174.         this.CreateBlockByType(this.HP)
  175.         this.Render()
  176.         return false
  177.     }
  179.     GetVertics() : Vec2[] {
  180.         let p1 = new Vec2(this.px - block_size * 0.5, this.py - block_size * 0.5)
  181.         let p2 = new Vec2(this.px - block_size * 0.5, this.py + block_size * 0.5)
  182.         let p3 = new Vec2(this.px + block_size * 0.5, this.py + block_size * 0.5)
  183.         let p4 = new Vec2(this.px + block_size * 0.5, this.py - block_size * 0.5)
  184.         return [p1, p2, p3, p4]
  185.     }
  187.     Render(){
  188.         this.block.setPosition(this.px, this.py)
  189.     }
  190. }
  192. class Item {
  193.     item : Sprite
  194.     x : number
  195.     y : number
  196.     speed : number
  197.     itemType : ItemType
  198.     constructor(x : number, y : number, itemType : ItemType) {
  199.         this.x = x
  200.         this.y = y
  201.         this.speed = 10
  202.         this.itemType = itemType
  203.         switch(itemType) {
  204.             case ItemType.Green:
  205.                 this.item = sprites.create(assets.image`two`, SpriteKind.Food)
  206.                 break
  207.             case ItemType.Yellow:
  208.                 this.item = sprites.create(assets.image`three`, SpriteKind.Food)
  209.                 break
  210.             case ItemType.Red:
  211.                 this.item = sprites.create(assets.image`four`, SpriteKind.Food)
  212.                 break
  213.             case ItemType.Purple:
  214.                 this.item = sprites.create(assets.image`five`, SpriteKind.Food)
  215.                 break
  216.         }
  217.         this.item.setPosition(x, y)
  218.         this.item.setVelocity(0, this.speed)
  219.     }
  220. }
  222. let liveItems : Item[] = []
  224. sprites.onOverlap(SpriteKind.Food, SpriteKind.Player, function (foodSprite, playerSprite) {
  225.     music.beamUp.play()
  226.     for(let i = 0; i < liveItems.length; ++i) {
  227.         let curItem = liveItems[i]
  228.         if(curItem.item == foodSprite) {
  229.             let deadItem = liveItems.removeAt(i)
  230.             deadItem.item.destroy()
  231.             if(ballList.length < 25) {
  232.                 GenNewBall(deadItem.itemType)
  233.             } else {
  234.                 for(let ii = 0; ii < ballList.length; ++ii) {
  235.                     let curBall = ballList[ii]
  236.                     curBall.SpeedUp(0.2)
  237.                 }
  238.             }
  239.             break 
  240.         }
  241.     }
  242. })
  243. let D2R = Math.PI / 180
  245. function RotateVector(v : Vec2, angle : number, isClockwise : boolean) : Vec2 {
  246.     let vv : Vec2
  247.     if(isClockwise == true) {
  248.         vv = new Vec2(-v.y, v.x)
  249.     } else {
  250.         vv = new Vec2(v.y, -v.x)
  251.     }
  252.     let xl : number
  253.     let yl : number
  254.     xl = Math.cos(angle * D2R)
  255.     yl = Math.sin(angle * D2R)
  257.     let xx = v.Mul(xl)
  258.     let yy = vv.Mul(yl)
  260.     let newV : Vec2 = xx.Add(yy)
  262.     return newV
  263. }
  265. function GenNewBall(count : number) {
  266.     if(ballList.length > 100) {
  267.         return
  268.     }
  270.     let newBalls : Ball[] = []
  271.     if(count == 2) {
  272.         for(let i = 0; i < ballList.length; ++i) {
  273.             let curBall = ballList[i]
  274.             let v1 = RotateVector(curBall.GetDir(), 15, true)
  275.             let v2 = RotateVector(curBall.GetDir(), 15, false)
  276.             curBall.SetVelocity(v1)
  277.             let pos = curBall.GetPos()
  278.             let ball = new Ball(pos.x, pos.y, v2)
  279.             newBalls.push(ball)
  280.         }
  281.     } else if(count == 3) {
  282.         for(let i = 0; i < ballList.length; ++i) {
  283.             let curBall = ballList[i]
  284.             let v1 = RotateVector(curBall.GetDir(), 120, true)
  285.             let v2 = RotateVector(curBall.GetDir(), 120, false)
  286.             let pos = curBall.GetPos()
  287.             let ball1 = new Ball(pos.x, pos.y, v1)
  288.             let ball2 = new Ball(pos.x, pos.y, v2)
  289.             newBalls.push(ball1)
  290.             newBalls.push(ball2)
  291.         }
  292.     } else if(count == 4) {
  293.         for(let i = 0; i < ballList.length; ++i) {
  294.             let curBall = ballList[i]
  295.             let v1 = RotateVector(curBall.GetDir(), 15, true)
  296.             let v2 = RotateVector(curBall.GetDir(), 45, true)
  297.             let v3 = RotateVector(curBall.GetDir(), 15, false)
  298.             let v4 = RotateVector(curBall.GetDir(), 45, false)
  299.             curBall.SetVelocity(v1)
  300.             let pos = curBall.GetPos()
  301.             let ball2 = new Ball(pos.x, pos.y, v2)
  302.             let ball3 = new Ball(pos.x, pos.y, v3)
  303.             let ball4 = new Ball(pos.x, pos.y, v4)
  304.             newBalls.push(ball2)
  305.             newBalls.push(ball3)
  306.             newBalls.push(ball4)
  307.         }
  308.     } else if(count == 5) {
  309.         for(let i = 0; i < ballList.length; ++i) {
  310.             let curBall = ballList[i]
  311.             let v1 = RotateVector(curBall.GetDir(), 72, true)
  312.             let v2 = RotateVector(curBall.GetDir(), 144, true)
  313.             let v3 = RotateVector(curBall.GetDir(), 72, false)
  314.             let v4 = RotateVector(curBall.GetDir(), 144, false)
  315.             let pos = curBall.GetPos()
  316.             let ball1 = new Ball(pos.x, pos.y, v1)
  317.             let ball2 = new Ball(pos.x, pos.y, v2)
  318.             let ball3 = new Ball(pos.x, pos.y, v3)
  319.             let ball4 = new Ball(pos.x, pos.y, v4)
  320.             newBalls.push(ball1)
  321.             newBalls.push(ball2)
  322.             newBalls.push(ball3)
  323.             newBalls.push(ball4)
  324.         }
  325.     }
  327.     for(let i = 0; i < newBalls.length; ++i) {
  328.         ballList.push(newBalls[i])
  329.     }
  330. }
  332. function IsIntersection(p1 : Vec2, p2 : Vec2, p3 : Vec2, p4 : Vec2) : boolean {
  333.     if(ToLeft(p1, p2, p3) && ToLeft(p1, p2, p4)) {
  334.         return false
  335.     }
  337.     if(!ToLeft(p1, p2, p3) && !ToLeft(p1, p2, p4)) {
  338.         return false
  339.     }
  341.     if(ToLeft(p3, p4, p1) && ToLeft(p3, p4, p2)) {
  342.         return false
  343.     }
  345.     if(!ToLeft(p3, p4, p1) && !ToLeft(p3, p4, p2)) {
  346.         return false
  347.     }
  349.     return true
  350. }
  352. let BlocksObjects : MyBlock[] = []
  354. for(let i = 0; i < row; ++i) {
  355.     for(let j = 0; j < col; ++j) {
  356.         if(Blocks[i][j] > 0) {
  357.             BlocksObjects.push(new MyBlock(j, i, Blocks[i][j]))
  358.         }
  359.     }
  360. }
  362. let platform = new Platform(w / 2, h - 20)
  363. let ballList : Ball[] = []
  365. ballList.push(new Ball(w / 2, h / 2, new Vec2(1, 1)))
  367. for(let i = 0; i < BlocksObjects.length; ++i)
  368. {
  369.     BlocksObjects[i].Render()
  370. }
  372. function GetCollisionEdge(sprite : Sprite, otherSprite : Sprite) : CollisionEdge {
  373.     let otherTop = otherSprite.top
  374.     let otherBottom = otherSprite.bottom
  375.     let otherLeft = otherSprite.left
  376.     let otherRight = otherSprite.right
  378.     let otherCenter = new Vec2(otherLeft / 2 + otherRight / 2, otherTop / 2 + otherBottom / 2)
  379.     let otherLeftTop = new Vec2(otherLeft, otherTop)
  380.     let otherLeftBottom = new Vec2(otherLeft, otherBottom)
  381.     let otherRightTop = new Vec2(otherRight, otherTop)
  382.     let otherRightBottom = new Vec2(otherRight, otherBottom)
  384.     let top = sprite.top
  385.     let bottom = sprite.bottom
  386.     let left = sprite.left
  387.     let right = sprite.right
  389.     let center = new Vec2(left / 2 + right / 2, top / 2 + bottom / 2)
  390.     let leftTop = new Vec2(left, top)
  391.     let leftBottom = new Vec2(left, bottom)
  392.     let rightTop = new Vec2(right, top)
  393.     let rightBottom = new Vec2(right, bottom)
  395.     if(IsIntersection(center, otherCenter, otherLeftTop, otherLeftBottom)) {
  396.         return CollisionEdge.Left
  397.     } else if(IsIntersection(center, otherCenter, otherRightTop, otherRightBottom)) {
  398.         return CollisionEdge.Right
  399.     } else if(IsIntersection(center, otherCenter, otherLeftTop, otherRightTop)) {
  400.         return CollisionEdge.Top
  401.     }else if(IsIntersection(center, otherCenter, otherLeftBottom, otherRightBottom)) {
  402.         return CollisionEdge.Bottom
  403.     }
  405.     return CollisionEdge.None
  406. }
  408. sprites.onOverlap(SpriteKind.Projectile, SpriteKind.Player, function (sprite, otherSprite) {
  409.     let edge = GetCollisionEdge(sprite, otherSprite)
  410.     music.pewPew.play()
  411.     switch(edge)
  412.     {
  413.         case CollisionEdge.Top:
  414.             if(sprite.vy > 0){
  415.                 sprite.vy = -sprite.vy
  416.                 if(sprite.x < otherSprite.x) {
  417.                     sprite.vx -= randint(0, 10) / 10.0
  418.                 } else if(sprite.x > otherSprite.x) {
  419.                     sprite.vx += randint(0, 10) / 10.0
  420.                 }
  421.             }
  422.             break
  423.         case CollisionEdge.Bottom:
  424.             if(sprite.vy < 0){
  425.                 sprite.vy = -sprite.vy
  426.             }
  427.             break
  428.         case CollisionEdge.Left:
  429.             if(sprite.vx > 0) {
  430.                 sprite.vx = -sprite.vx
  431.             }
  432.             break
  433.         case CollisionEdge.Right:
  434.             if(sprite.vx < 0){
  435.                 sprite.vx = -sprite.vx
  436.             }
  437.             break
  438.     }
  439. })
  441. sprites.onOverlap(SpriteKind.Projectile, SpriteKind.Enemy, function (sprite, otherSprite) {
  442.     let edge = GetCollisionEdge(sprite, otherSprite)
  443.     let r = randint(1, 100)
  444.     if(r > 80 && ballList.length < 25 && liveItems.length < 3) {
  445.         let item = new Item(sprite.x, sprite.y, randint(2, 5))
  446.         liveItems.push(item)
  447.     }
  449.     switch(edge)
  450.     {
  451.         case CollisionEdge.Top:
  452.             if(sprite.vy > 0){
  453.                 sprite.vy = -sprite.vy * 1.05
  454.             }
  455.             break
  456.         case CollisionEdge.Bottom:
  457.             if(sprite.vy < 0){
  458.                 sprite.vy = -sprite.vy * 1.05
  459.             }
  460.             break
  461.         case CollisionEdge.Left:
  462.             if(sprite.vx > 0) {
  463.                 sprite.vx = -sprite.vx * 1.05
  464.             }
  465.             break
  466.         case CollisionEdge.Right:
  467.             if(sprite.vx < 0){
  468.                 sprite.vx = -sprite.vx * 1.05
  469.             }
  470.             break
  471.     }
  473.     for(let i = 0; i < BlocksObjects.length; ++i) {
  474.         let myBlock = BlocksObjects[i]
  475.         if(myBlock.block == otherSprite) {
  476.             if(myBlock.BeBreakOut() == true) {
  477.                 let item = BlocksObjects.removeAt(i)
  478.                 item.block.destroy()
  479.                 if(BlocksObjects.length == 0) {
  480.                     music.powerUp.play()
  481.                 }
  482.             }
  483.             break 
  484.         }
  485.     }
  486. })
  488. game.onUpdate(function() {
  489.     let background = scene.backgroundImage();
  490.     background.fill(0)
  492.     for(let i = ballList.length - 1; i >= 0; --i)
  493.     {
  494.         let pos = ballList[i].GetPos()
  495.         if(pos.y > 117) {
  496.             let ball = ballList.removeAt(i)
  497.             ball.ball.destroy()
  498.         }
  499.     }
  500. })