使用vue3写一个超大号俄罗斯方块

前几天写了一个贪吃蛇的demo，最近两天很闲还在继续摸鱼。所以又做了一个俄罗斯方块

WechatIMG2.jpg

可以自由设置大小，带下落的辅助线

image.png

方块下落位置在横坐标是随机的，方块可以左右互相跨越瞬移，可以存储到localStorage下次继续游戏

用二维数组控制场地的渲染

可以把地图看成是一个二维的数组，然后用不同的数字表示不同的方块，如果方块已经落地，就变为负数，判断方块触底和判断方块移动的时候左右两边有没有方块就是通过方块的正数，和已经触底的负数做对比，所以数组的最下面多加了一个全是-1的数组，用来表示底部

css
复制代码
[	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[-6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
	[-6, -6, -6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, -2],
	[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]
]

7种俄罗斯方块的形状

地图用二维数组表示，那么方块同样也用二维数组表示 俄罗斯方块一共有7种

分别是O,I,S,Z,L,J,T型

比如这两个，代表了J型和T型

csharp
复制代码
6: {
  name: 'J型',
  backgroundColor: '#FFC0CB',
  data: [
    [0, 6],
    [0, 6],
    [6, 6]
  ]
},
7: {
  name: 'T型',
  backgroundColor: '#BA55D3',
  data: [
    [7, 7, 7],
    [0, 7, 0]
  ]
}

方块的变形

方块可以旋转变形，本来想把7种变形的方式全部穷举出来，但是考虑到有些形状变形方式有4种，比如T型，但是有些只有一种，比如I型，所以这里用了一种矩阵旋转的算法

ini
复制代码
// 设置方块转动
  const getBlockTurn = (block: any) => {
    return rotateMatrix(block)
  }

  const rotateMatrix = (matrix: any) => {
    const rows = matrix.length
    const cols = matrix[0].length
    const transposed: any = []
    for (let i = 0; i < cols; i++) {
      transposed.push([])
      for (let j = 0; j < rows; j++) {
        transposed[i][j] = matrix[j][i]
      }
    }
    const rotated = transposed.map((row: any) => row.reverse())
    return rotated
  }

  return { getBlock, getRandomNumber, getBlockTurn }

这里把和获取方块变形方块相关的逻辑放在组合式函数里，使用的时候直接传入方块获取选择之后的方块

方块的移动

做的时候方块向下移动是最让我头疼的，思索了一天，最终做了出来但是感觉方法不是很理想，思路是循环方块的二维数组，然后通过递增向下的fallIndex，循环插入到地图的二维数组中

ini
复制代码
// 每次下落clone一遍
    const cloneSourceCodes = JSON.parse(JSON.stringify(cloneArr))
    const len = 4 - block.value.length // 4代表方块的底部从第几层开始下落
    // 反着遍历落块的每一层，从第4层对齐
    for (let i = block.value.length - 1; i >= 0; i--) {
      const nowRow = cloneSourceCodes[fallIndex.value + len + i]
      // 方块的每一层遍历一遍，不等于0的插入
      for (let j = 0; j < block.value[i].length; j++) {
        if (block.value[i][j] !== 0) {
          nowRow.splice(start.value + j, 1, block.value[i][j])
        }
      }
    }
    // 检测是否碰撞
    for (let i = 0; i < cloneSourceCodes.length; i++) {
      if (isCollisions(cloneSourceCodes[i], cloneSourceCodes[i + 1])) {
        sourceCodes.value = SetAlreadyFallen(cloneSourceCodes)
        clearInterval(timer)
        newBegin()
        return
      }
    }

碰撞的逻辑

判断方块和底部接触，方块和方块直接碰撞，或者左右移动的时候左右两边的方块阻挡 通过方块的正数，和负数来对比

typescript
复制代码
// 检测碰撞
  const isCollisions = (nowRow: any, nextRow: any) => {
    //  如果这一行不为0的位置的下一行，是负数，说明有东西会碰撞
    for (let i = 0; i < nowRow.length; i++) {
      if (nowRow[i] > 0 && nextRow[i] < 0) {
        return true
      }
    }
    return false
  }

方块的左右移动

方块下落的时候，我没有设置从中间下落，而是从顶部的随机位置下落

向下移动的时候，是通过一个fallIndex来控制，左右移动的时候，通过startIndex来控制

这里还加了一个isTeleporting的配置，代表向左移动到边缘的时候是否能瞬移到右边

ini
复制代码
const setLeftRight = (direction: 'left' | 'right') => {
    // 判断左右两边是否有方块 或者左下角或者右下角有方块
    for (let i = 0; i < sourceCodes.value.length; i++) {
      for (let j = 0; j < sourceCodes.value[i].length; j++) {
        if (
          (sourceCodes.value[i][j] > 0 &&
            (sourceCodes.value[i][j - 1] < 0 ||
              sourceCodes.value[i + 1][j - 1] < 0) &&
            direction === 'left') ||
          (sourceCodes.value[i][j] > 0 &&
            (sourceCodes.value[i][j + 1] < 0 ||
              sourceCodes.value[i + 1][j + 1] < 0) &&
            direction === 'right')
        ) {
          return
        }
      }
    }
    // 是否左右瞬移
    if (isTeleporting) {
      if (start.value === maxStart.value && direction === 'right') {
        start.value = 0
      } else if (start.value === 0 && direction === 'left') {
        start.value = maxStart.value
      } else {
        start.value += direction === 'left' ? -1 : 1
      }
    } else {
      if (direction === 'left' && start.value > 0) {
        start.value--
      }
      if (direction === 'right' && start.value < maxStart.value) {
        start.value++
      }
    }
    moveBlockDown()
  }

方块向下加速

方块下落加速的时候，先清除定时器，然后给定时器函数传入一个小点的数值

scss
复制代码
const fallBlock = () => {
    clearInterval(timer)
    startBlockFalling(10)
  }
  
  const startBlockFalling = (changeDelay?: number) => {
    timer = setInterval(() => {
      moveBlockDown()
      fallIndex.value++
    }, changeDelay || delay.value)
  }

消除整行

typescript
复制代码
const clearFilledRows = () => {
    const rows = cloneArr[0].length
    const upArr = cloneArr.slice(0, -1)
    const filledRows = upArr.filter((row: any) =>
      row.every((cell: any) => cell !== 0)
    )
    const filterArr = upArr.filter((row: any) => row.includes(0))
    if (filledRows.length > 0) {
      scoreRows.value += filledRows.length
      const emptyRows = filledRows.map(() => Array(rows).fill(0))
      filterArr.unshift(...emptyRows)
    }
    const bottom = Array(rows).fill(-1)
    cloneArr = [...filterArr, bottom]
    const gameover = cloneArr[4].find((row: any) => row < 0)
    if (gameover) {
      isGameOver.value = true
    }
    sourceCodes.value = cloneArr
    return Promise.resolve(cloneArr)
  }

完整代码

目录结构

image.png

首页

index.tsx
复制代码


import {
  defineComponent
  onMounted,
  computed
} from 'vue'
import './index.scss'
import config from './config'
import { setGameInterface } from './helpers/setGameInterface'

import { useGetBlock } from './hooks/useGetBlock'
import { useHandleCode } from './hooks/useHandleCode'

export default defineComponent({
  components: {},
  props: {},
  emits: [''],
  setup() {
    // 设置视图宽高css
    const { viewStyle } = setGameInterface()

    // 获取配置
    const { isShowTop, sourceBlockTypes, isAuxiliaryShow } = config

    // 获取随机方块
    const { getBlock, getBlockTurn } = useGetBlock()

    // 操作二维地图数组源码
    const {
      scoreRows,
      isGameOver,
      newStartGame,
      sourceCodes,
      nextBlock,
      start
    } = useHandleCode(getBlock, getBlockTurn)

    onMounted(() => {})

    // 设置下一个显示
    const nextBlockWrap = computed(() => {
      if (nextBlock.value && nextBlock.value) {
        const result = JSON.parse(JSON.stringify(nextBlock.value))
        if (result && result[0]) {
          const rows = result[0].length
          console.log(rows)
          result.forEach((item: any) => {
            if (rows === 1) {
              item.push(...Array(2).fill(0))
              item.unshift(...Array(1).fill(0))
            } else if (rows === 2) {
              item.push(...Array(1).fill(0))
              item.unshift(...Array(1).fill(0))
            } else {
              item.push(...Array(4 - rows).fill(0))
            }
          })
        }
        if (result.length === 2) {
          result.push(...Array(1).fill(Array(4).fill(0)))
          result.unshift(...Array(1).fill(Array(4).fill(0)))
        } else {
          result.push(...Array(4 - result.length).fill(Array(4).fill(0)))
        }

        return result
      } else {
        return []
      }
    })

    return () => {
      return (
        

          

            

              
游戏结束

              
已消除：{scoreRows.value}行

              
                onClick={() => {
                  newStartGame()
                }}
              >
                重新开始
              
            

            {sourceCodes.value.map((column: any, index: number) => {
              return (
                
                  class={`tetris-column column-${index}`}
                  style={[
                    `${index > 0 ? 'border-top:1px solid #ccc' : ''}`,
                    `${index < 4 ? 'background-color:red' : ''}`
                  ]}
                  v-show={
                    (isShowTop || (!isShowTop && index > 3)) &&
                    index !== sourceCodes.value.length - 1
                  }
                >
                  {/* 行 */}
                  {column.map((cell: any, cellIndex: number) => {
                    return (
                      
                        class={`tetris-cell cell-${Math.abs(cell)}`}
                        style={[
                          `background-color:${
                            sourceBlockTypes[Math.abs(cell)].backgroundColor
                          }`,
                          `${
                            cellIndex > 0 ? 'border-left:1px solid #DCDCDC' : ''
                          }`,
                          `${
                            cellIndex === start.value && isAuxiliaryShow
                              ? 'border-left:1px dashed #696969'
                              : ''
                          }`
                        ]}
                      >
                        {/* {cell} */}
                      

                    )
                  })}
                

              )
            })}

已消除：{scoreRows.value}行

下一个
{nextBlockWrap.value.map((column: any, index: number) => { return (
{/* 行 */} {column.map((cell: any) => { return ( class={`tetris-cell cell-${Math.abs(cell)}`} style={[ `background-color:${ sourceBlockTypes[Math.abs(cell)].backgroundColor }` ]} > {/* {cell} */}
) })}
) })}
) } } })

配置

config.ts
复制代码
export default {
  gridWidth: 20,
  gridHeight: 40,
  isRandomFall: true, // 是否是从顶部随机位置下落
  isShowTop: false, // 是否显示上面四格，显示初始位置的地方，游戏的时候去掉
  isTeleporting: true, // 是否允许瞬移,即移动到最左边从右边出现
  isAuxiliaryShow: true, // 是否显示辅助线
  isStore: true, // 是否存储
  sourceBlockTypes: {
    0: {
      name: '',
      backgroundColor: '',
      data: []
    },
    1: {
      name: 'O型',
      backgroundColor: '#FFD700',
      data: [
        [1, 1],
        [1, 1]
      ]
    },
    2: {
      name: 'I型',
      backgroundColor: '#1E90FF',
      data: [[2], [2], [2], [2]]
    },
    3: {
      name: 'S型',
      backgroundColor: '#DC143C',
      data: [
        [0, 3, 3],
        [3, 3, 0]
      ]
    },
    4: {
      name: 'Z型',
      backgroundColor: '#3CB371',
      data: [
        [4, 4, 0],
        [0, 4, 4]
      ]
    },
    5: {
      name: 'L型',
      backgroundColor: '#DAA520',
      data: [
        [5, 0],
        [5, 0],
        [5, 5]
      ]
    },

    6: {
      name: 'J型',
      backgroundColor: '#FFC0CB',
      data: [
        [0, 6],
        [0, 6],
        [6, 6]
      ]
    },
    7: {
      name: 'T型',
      backgroundColor: '#BA55D3',
      data: [
        [7, 7, 7],
        [0, 7, 0]
      ]
    }
  }
}

获取随机方块、方块转动

useGetBlock.ts
复制代码

import { ref } from 'vue'
import config from '../config'
export const useGetBlock = () => {
  const block: any = ref([])
  // 获取方块类型
  const { sourceBlockTypes } = config
  // 获取随机数范围
  const getRandomNumber = (min: number, max: number): number => {
    return Math.floor(Math.random() * (max - min + 1)) + min
  }
  // 获取随机方块
  const getRandomBlocks = () => {
    const blocks = Object.keys(sourceBlockTypes)
    const key = getRandomNumber(1, blocks.length - 1)
    const block = sourceBlockTypes[key]
    return block.data
  }

  const getBlock = () => {
    block.value = getRandomBlocks()
    return block.value
  }

  // 设置方块转动
  const getBlockTurn = (block: any) => {
    return rotateMatrix(block)
  }

  const rotateMatrix = (matrix: any) => {
    const rows = matrix.length
    const cols = matrix[0].length
    const transposed: any = []
    for (let i = 0; i < cols; i++) {
      transposed.push([])
      for (let j = 0; j < rows; j++) {
        transposed[i][j] = matrix[j][i]
      }
    }
    const rotated = transposed.map((row: any) => row.reverse())
    return rotated
  }

  return { getBlock, getRandomNumber, getBlockTurn }
}

方块的移动操作

useHandleCode.ts
复制代码

import { ref, onMounted, watch } from 'vue'
import config from '../config'
import { useGetBlock } from './useGetBlock'
import { useKeyDown } from './useKeyDown'
import { useSetSourceCode } from './useSetSourceCode'

export const useHandleCode = (
  getBlock: any,
  getBlockTurn: any
  // sourceCodes: Ref
) => {
  // 获取键盘事件
  const { onKeyDown } = useKeyDown()

  // 键盘操作
  onKeyDown((direction: 'left' | 'right' | 'up' | 'down' | 'stop' | '') => {
    if (direction === 'up') {
      // 变形
      changeBlock()
    }
    if (direction === 'left' || direction === 'right') {
      // 左右移动
      setLeftRight(direction)
    }
    if (direction === 'down') {
      // 快速下落
      fallBlock()
    }
    // 暂停
    if (direction === 'stop') {
      if (timer) {
        clearInterval(timer)
        timer = undefined
      } else {
        startBlockFalling()
      }
    }
  })

  // 获取源码
  const { sourceCodes, getNewSourceCodes } = useSetSourceCode()

  // 获取配置
  const { isTeleporting, isStore } = config

  // 获取范围随机数
  const { getRandomNumber } = useGetBlock()

  const fallIndex = ref(0) // 下落的步进索引
  const delay = ref(400) // 下落速度
  const scoreRows = ref(0) // 消除的行数
  const isGameOver = ref(false)
  let timer: any = null

  // 设置游戏难度
  watch(
    () => scoreRows.value,
    () => {
      if (delay.value > 50) {
        delay.value = 400 - scoreRows.value
      }
    }
  )

  const block = ref(getBlock())
  const nextBlock = ref([])

  const maxStart = ref(sourceCodes.value[0].length - block.value[0].length) // 插入的最大位置
  const start = ref(getRandomNumber(0, maxStart.value)) // 设置插入的随机范围

  // 获取存储的数据，继续上次游戏
  let cloneArr: any
  const storedSourceCodes = localStorage.getItem('sourceCodes')
  if (storedSourceCodes && isStore) {
    sourceCodes.value = JSON.parse(storedSourceCodes)
  }
  cloneArr = JSON.parse(JSON.stringify(sourceCodes.value))

  /**
   * @description: 游戏失败后重新开始游戏
   * @Date: 2023-11-24 10:08:25
   * @Author: zengzhaoyan
   */
  const newStartGame = () => {
    getNewSourceCodes()
    cloneArr = JSON.parse(JSON.stringify(sourceCodes.value))
    isGameOver.value = false
    newBegin()
  }

  /**
   * @description: 重新开始下落方块
   * @Date: 2023-11-22 16:35:28
   * @Author: zengzhaoyan
   */
  const newBegin = async () => {
    clearInterval(timer)
    cloneArr = JSON.parse(JSON.stringify(sourceCodes.value))
    await clearFilledRows()
    if (isGameOver.value) {
      return
    }
    const isempty = cloneArr[cloneArr.length - 2].every((row: any) => row === 0)
    if (!isempty) {
      localStorage.setItem('sourceCodes', JSON.stringify(cloneArr))
    }
    fallIndex.value = 0
    if (nextBlock.value.length) {
      block.value = nextBlock.value
    } else {
      block.value = getBlock()
    }
    nextBlock.value = getBlock()
    // console.log(nextBlock.value)
    maxStart.value = sourceCodes.value[0].length - block.value[0].length
    start.value = getRandomNumber(0, maxStart.value)
    startBlockFalling()
  }

  /**
   * @description: 设置方块自动下落定时函数
   * @Date: 2023-11-22 15:14:34
   * @Author: zengzhaoyan
   */
  const startBlockFalling = (changeDelay?: number) => {
    timer = setInterval(() => {
      moveBlockDown()
      fallIndex.value++
    }, changeDelay || delay.value)
  }

  onMounted(newBegin)

  /**
   * @description: 清除行
   * @Date: 2023-11-23 17:28:56
   * @Author: zengzhaoyan
   */
  const clearFilledRows = () => {
    const rows = cloneArr[0].length
    const upArr = cloneArr.slice(0, -1)
    const filledRows = upArr.filter((row: any) =>
      row.every((cell: any) => cell !== 0)
    )
    const filterArr = upArr.filter((row: any) => row.includes(0))
    if (filledRows.length > 0) {
      scoreRows.value += filledRows.length
      const emptyRows = filledRows.map(() => Array(rows).fill(0))
      filterArr.unshift(...emptyRows)
    }
    const bottom = Array(rows).fill(-1)
    cloneArr = [...filterArr, bottom]
    const gameover = cloneArr[4].find((row: any) => row < 0)
    if (gameover) {
      isGameOver.value = true
    }
    sourceCodes.value = cloneArr
    return Promise.resolve(cloneArr)
  }

  /**
   * @description: 设置方块位置
   * @Date: 2023-11-23 14:42:23
   * @Author: zengzhaoyan
   */
  const moveBlockDown = () => {
    // 每次下落clone一遍
    const cloneSourceCodes = JSON.parse(JSON.stringify(cloneArr))
    const len = 4 - block.value.length // 4代表方块的底部从第几层开始下落
    // 反着遍历落块的每一层，从第4层对齐
    for (let i = block.value.length - 1; i >= 0; i--) {
      const nowRow = cloneSourceCodes[fallIndex.value + len + i]
      // 方块的每一层遍历一遍，不等于0的插入
      for (let j = 0; j < block.value[i].length; j++) {
        if (block.value[i][j] !== 0) {
          nowRow.splice(start.value + j, 1, block.value[i][j])
        }
      }
    }
    // 检测是否碰撞
    for (let i = 0; i < cloneSourceCodes.length; i++) {
      if (isCollisions(cloneSourceCodes[i], cloneSourceCodes[i + 1])) {
        sourceCodes.value = SetAlreadyFallen(cloneSourceCodes)
        clearInterval(timer)
        newBegin()
        return
      }
    }
    sourceCodes.value = cloneSourceCodes
  }

  // 检测碰撞
  const isCollisions = (nowRow: any, nextRow: any) => {
    //  如果这一行不为0的位置的下一行，是负数，说明有东西会碰撞
    for (let i = 0; i < nowRow.length; i++) {
      if (nowRow[i] > 0 && nextRow[i] < 0) {
        return true
      }
    }
    return false
  }

  // 已经落下的方块设置为负数和正在下落的区分开
  const SetAlreadyFallen = (arr: any) => {
    return arr.map((row: any) =>
      row.map((value: any) => (value !== 0 ? -Math.abs(value) : 0))
    )
  }

  /**
   * @description: 设置方块左右移动
   * @Date: 2023-11-22 14:51:01
   * @Author: zengzhaoyan
   * @param {*} direction
   */
  const setLeftRight = (direction: 'left' | 'right') => {
    // 判断左右两边是否有方块 或者左下角或者右下角有方块
    for (let i = 0; i < sourceCodes.value.length; i++) {
      for (let j = 0; j < sourceCodes.value[i].length; j++) {
        if (
          (sourceCodes.value[i][j] > 0 &&
            (sourceCodes.value[i][j - 1] < 0 ||
              sourceCodes.value[i + 1][j - 1] < 0) &&
            direction === 'left') ||
          (sourceCodes.value[i][j] > 0 &&
            (sourceCodes.value[i][j + 1] < 0 ||
              sourceCodes.value[i + 1][j + 1] < 0) &&
            direction === 'right')
        ) {
          return
        }
      }
    }
    // 是否左右瞬移
    if (isTeleporting) {
      if (start.value === maxStart.value && direction === 'right') {
        start.value = 0
      } else if (start.value === 0 && direction === 'left') {
        start.value = maxStart.value
      } else {
        start.value += direction === 'left' ? -1 : 1
      }
    } else {
      if (direction === 'left' && start.value > 0) {
        start.value--
      }
      if (direction === 'right' && start.value < maxStart.value) {
        start.value++
      }
    }
    moveBlockDown()
  }

  /**
   * @description: 切换方块形状
   * @Date: 2023-11-22 14:50:18
   * @Author: zengzhaoyan
   */
  const changeBlock = () => {
    // clearInterval(timer)
    block.value = getBlockTurn(block.value)
    // 重新计算右边边界
    maxStart.value = sourceCodes.value[0].length - block.value[0].length
    moveBlockDown()
  }

  /**
   * @description: 快速下落方块
   * @Date: 2023-11-22 14:50:51
   * @Author: zengzhaoyan
   */
  const fallBlock = () => {
    clearInterval(timer)
    startBlockFalling(10)
  }

  return {
    start,
    block,
    sourceCodes,
    isGameOver,
    scoreRows,
    newStartGame,
    nextBlock
  }
}

设置游戏源码

useSetSourceCode.ts
复制代码
import config from '../config'
import { ref } from 'vue'

export const useSetSourceCode = () => {
  const { gridWidth, gridHeight } = config
  const sourceCodes: any = ref([])

  const getNewSourceCodes = () => {
    sourceCodes.value = []
    for (let i = 0; i < gridHeight; i++) {
      sourceCodes.value.push([])
      for (let j = 0; j < gridWidth; j++) {
        sourceCodes.value[i].push(0)
      }
    }
    // 添加一层负数垫底
    sourceCodes.value.push(Array(gridWidth).fill(-1))
  }

  getNewSourceCodes()

  return {
    getNewSourceCodes,
    sourceCodes
  }
}

设置游戏地图画面，布局

setGameInterface.ts
复制代码
import config from '../config'
import { useMain } from '@/hooks/useMain'

export const setGameInterface = () => {
  const { gridWidth, gridHeight, isShowTop } = config

  const height = isShowTop ? gridHeight : gridHeight - 4 // 减去4格不显示

  const { mainHeight } = useMain()

  return {
    viewHeight: mainHeight.value,
    viewWidth: (mainHeight.value / height) * gridWidth,
    viewStyle: `width:${(mainHeight.value / height) * gridWidth}px;height:${
      mainHeight.value
    }px;`
  }
}

键盘事件

useKeyDown.ts
复制代码

import { onMounted, onUnmounted } from 'vue'
type Direction = 'left' | 'right' | 'up' | 'down' | 'stop' | ''

export const useKeyDown = () => {
  const onKeyDown = (callback: (direction: Direction) => void) => {
    // 键盘操作
    const handleKeyPress = (event: KeyboardEvent) => {
      if (['w', 'a', 's', 'd', 'r'].includes(event.key)) {
        const keyMap: Record = {
          w: 'up',
          a: 'left',
          s: 'down',
          d: 'right',
          r: 'stop'
        }
        const direction: Direction = keyMap[event.key] || ''
        callback(direction)
      }
    }
    
    onMounted(() => {
      window.addEventListener('keydown', handleKeyPress)
    })
    
    onUnmounted(() => {
      window.removeEventListener('keydown', handleKeyPress)
    })
  }
  return {
    onKeyDown
  }
}

样式

index.scss
复制代码
.tetris-wrap {
  display: flex;
  align-items: center;
  justify-content: center;
  opacity: 1;
  
  .tetris-content,
  .tetris-msg {
    border: 1px solid #000000;
    display: flex;
    flex-direction: column;
    .tetris-column {
      flex: 1;
      display: flex;
      flex-direction: row;
      .tetris-cell {
        flex: 1;
      }
    }
  }
  .tetris-msg {
    width: 100px;
    height: 100px;
    border: none;
  }
}
id="article_content" class="article_content clearfix"> id="content_views" class="htmledit_views">

代理IP工具在网络安全中扮演着至关重要的角色，它们不仅能够帮助用户保护隐私，还能提高网络性能，增强安全性。本文将深入探讨代理IP工具的定义、工作原理以及在网络安全中的具体应用，旨在为读者提供全面的理解和指导。

一、代理IP工具的定义与工作原理

代理IP是一种通过中间服务器进行网络通信的工具。当用户使用代理IP时，其真实IP地址会被替换为代理服务器的IP地址。这意味着，用户的网络请求首先发送到代理服务器，然后由代理服务器转发到目标网站。目标网站在接收请求时，只能看到代理服务器的IP地址，而无法直接获取用户的本地IP地址。这一机制为用户提供了额外的隐私保护，并允许用户绕过某些网络限制。

二、​代理IP在网络安全中的具体应用

1、隐私保护

代理IP工具的主要功能之一是保护用户的隐私。通过使用代理IP，用户可以隐藏自己的真实IP地址，提高在互联网上的匿名性。这不仅有助于防止个人信息泄露，还能防止不法分子进行跟踪和滥用。对于担心个人隐私安全的用户来说，代理IP是一个有效的解决方案。

2、突破访问限制

在某些地区或网络环境中，特定网站可能被屏蔽或限制访问。通过代理IP，用户可以绕过这些地域限制，自由访问被封锁的内容。这对于需要访问某些资源的用户来说尤为重要。

3、安全测试

安全专业人士可以使用代理IP进行渗透测试和安全评估。通过模拟不同地区和来源的攻击，他们可以测试系统的安全性，并发现潜在的漏洞。这种测试有助于企业及时修复安全问题，提高系统的整体防御能力。

4、数据采集与爬虫

代理IP在数据采集和爬虫抓取方面发挥着重要作用。通过使用代理IP，用户可以匿名抓取网页数据、监测竞争对手的动态，并避免被目标网站封禁或限制访问频率。这对于市场研究、竞品分析和数据挖掘等领域来说至关重要。

5、广告和SEO优化

在广告行业，代理IP可用于模拟不同地区的广告点击，以评估广告效果并优化投放策略。同时，在SEO优化中，通过代理IP检查搜索引擎结果在不同地区的展示情况，可以帮助企业制定更精准的市场推广计划。

6、提高访问速度

有时，代理IP可以加速访问速度。特别是在访问某些网站时，选择一个靠近目标服务器的代理服务器可以减少响应时间和网络延迟。这对于提高用户体验和效率至关重要。

7、网络营销推广

网络营销推广中常需要使用大量的IP地址来模拟不同用户的行为。通过代理IP工具，可以轻松地切换不同的IP地址，从而实现发帖、问答、注册账号等操作。这不仅有助于增加网站的曝光度和流量，还能提高网络营销的效果。

8、充当防火墙

代理IP工具还可以充当防火墙的作用，保护局域网免受外部攻击。通过代理IP地址，可以限制对内部网络的访问，并过滤掉恶意流量。这种防火墙功能为企业提供了额外的安全保障。

三、如何选择合适的代理IP工具

选择合适的代理IP工具，需从以下方面考虑：

（1）明确需求‌：

应用场景‌：确定代理IP将用于何种场景，如数据抓取、网络测试等‌。

匿名性‌：根据隐私保护需求，选择高匿名或透明代理‌。

（2）评估性能‌：

速度和稳定性‌：测试代理IP的响应速度和连接稳定性，确保高效访问‌。

（3）考察服务‌：

供应商信誉‌：选择信誉良好、服务可靠的品牌，确保长期稳定性‌。

客户支持‌：了解服务商是否提供/技术支持和合理试用期‌。

（4）考虑性价比‌：

在满足需求的前提下，选择性价比高的代理服务，避免不必要的费用‌。

四、代理IP工具使用指南

代理IP工具怎么使用？以国内的虎观代理IP安卓版为例，具体操作步骤如下

步骤1：下载与安装‌

前往虎观代理官网，下载并安装安卓版软件。

步骤2：‌注册与登录‌：

打开软件，进行注册并登录账号（实名注册可享免费试用）。

‌步骤3：选择线路与切换IP‌

进入软件后，点击“线路”选项，根据需求选择动态或静态IP线路。

点击“一键更换IP”，完成IP地址的切换。

‌步骤4：测试与调整‌

切换IP后，打开浏览器或其他应用测试代理效果。

如需自动更换IP，可设置定时切换功能。

五、注意事项与最佳实践

在使用代理IP工具时，用户应遵循以下注意事项和最佳实践：

定期更换IP：为了提高安全性和隐私保护，建议定期更换代理IP。这可以减少因IP被封导致的服务中断，并降低被识别的风险。

软件更新：保持代理服务器和客户端软件的更新，以修复已知的安全漏洞。这有助于提高整体的安全性。

合法合规：在使用代理IP时，务必遵循当地法律法规，避免进行任何非法活动。这有助于维护良好的网络环境和社会秩序。

技术支持：选择提供良好技术支持的服务商，以便在遇到问题时能够及时获得帮助和解决方案。

结尾：

总之，代理IP工具在网络安全中发挥着重要作用。它们不仅能够帮助用户保护隐私、提高网络性能，还能增强安全性。通过选择合适的代理IP工具并遵循最佳实践，用户可以享受更加自由、安全和高效的网络体验。

往期推荐：

代理IP地址的含义与设置指南‌

ip地址正确的格式不能超过多少位

windows怎样查看ip地址？这4个方法别错过

>>
注：本文转载自juejin.cn的bjdhbt的文章"https://juejin.cn/post/7304820397404569638"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！