none
Hola buenas tardes me podrian traducir este codigo a C o C++, muchas gracias de antemano. RRS feed

  • Pregunta

  • // title: Artilleria Pesada
    const names = 'Daniel Bernal Pedro Perez Juan Carlos Sanz'.split(' ')
    const introSprites = [
      [0, 1, 16, 17],
      [2, 3, 18, 19],
      [4, 5, 20, 21],
      [6, 7, 22, 23],
      [8, 9, 24, 25]
     ];
    init = state => {
      playPhrase(2)
      state.firstRunDone = false
      state.introTime = 0
      state.level = createLevel()
      state.modLevel = [...state.level]
      state.frame = 0
      state.time = 0
      let nameIndex1 = 0
      let nameIndex2 = 0
      while(nameIndex1 === nameIndex2) {
        nameIndex1 = names.length * Math.random() | 0
        nameIndex2 = names.length * Math.random() | 0
      }
      state.tanks = [
      //  Xpos   Ypos   Angle Power  Health  aimX   aimY   Name
        { x: 33, y: -6, a: 0, p: 10, h: 100, u: -1, v: -1, name: names[nameIndex1] },
        { x: 96, y: -6, a: 0, p: 10, h: 100, u: -1, v: -1, name: names[nameIndex2] }
      ];
      state.survivors = [...state.tanks];
      state.speedMul = 5
      state.lastTurn = 0
      state.turn = 0
      state.turnsPlayed = 0
      state.projectile = false
      state.explosion = false
      
      state.heldKeys = {
        a: false
      }
      
      state.winner = false;
      
      state.trajectory = [[],[]]
     }

    function createLevel() {
      const points = 128
      return Array.from(
        { length: points },
        (_, i) => [
          i, (96 + Math.random() * 128 - 64) | 0
        ]
      )
     }

    update = (state, input, elapsed) => {
      if(state.firstRunDone) {
        state.frame++
        if(!state.playing && state.time === 0) {
          initLevel(state)
          return
        }
        state.time += elapsed / 1000
        tankPhysics(state)
        tankInput(state, input)
        resetInput(state, input)
        projectilePhysics(state)
        updateTrajectory(state)
        updateExplode(state)
        
        state.survivors = getSurvivors(state)
      } else {
        state.introTime += elapsed
        if(input.a) {
          state.firstRunDone = true
        }
      }
     }

    function resetInput(state, input) {
      const survivors = getSurvivors(state)
      if(survivors.length <= 1 && input.a) {
        init(state)
        state.level = createLevel()
      }
     }

    function initLevel(state) {
      // Smooth level
      const lastLevel = (state.modLevel || state.level)
      state.modLevel = lastLevel.map((point, pointIndex) => {
        const prev = lastLevel[pointIndex - 1]
        const next = lastLevel[pointIndex + 1]
        if(!prev || !next) return point
        const newY = (prev[1] + point[1] + point[1] + point[1] + point[1] + point[1] + next[1]) / 7
        return [point[0], Math.min(126, newY | 0)]
      });
      if(state.frame === 48) state.playing = true
     }

    function tankPhysics(state) {
      state.tanks.filter(tank => {
        const ground = Math.min(state.modLevel[tank.x][1], 127)
        if(ground && tank.y < Math.floor(ground)) {
          return true;
        }
      }).forEach(tank => {
        tank.y++
        updateAim(tank)
      });
     }

    function tankInput(state, keys) {
      const tank = state.tanks[state.turn]
      if(!tank) return

      // angle
      if(keys.left) {
        tank.a-=0.005
      }
      if(keys.right) {
        tank.a+=0.005
      }

      // power
      if(keys.up)    tank.p += 0.5
      if(keys.down)  tank.p -= 0.5
      if(tank.p < 1)  tank.p = 1
      if(tank.p > 20) tank.p = 20

      // shoot
      if(keys.a && !state.heldKeys.a) {
        state.heldKeys.a = true
      }
      if(!keys.a && state.heldKeys.a) {
        state.heldKeys.a = false
        shoot(tank, state)
      }
      
      // aim
      if(keys.left || keys.right || keys.up || keys.down) {
        updateAim(tank)
      }
     }

    function updateAim(tank) {
      tank.u = tank.x +  Math.sin(tank.a * Math.PI * 2) * tank.p
      tank.v = tank.y + -Math.cos(tank.a * Math.PI * 2) * tank.p
     }

    function shoot(tank, state) {
      if(!state.playing) return
      
      clearTrajectory(state)
      playPhrase(4)
      
      state.lastTurn = state.turn
      state.turn = -1
      state.projectile = {
        x: tank.x,
        y: tank.y,
        xv:  Math.sin(tank.a * Math.PI * 2) * tank.p * 0.8,
        yv: -Math.cos(tank.a * Math.PI * 2) * tank.p * 0.8
      };
     }

    function projectilePhysics(state) {
      const p = state.projectile
      if(!p) return; // no active projectile

      p.x += p.xv/state.speedMul
      p.y += p.yv/state.speedMul
      p.yv += 1/state.speedMul
      const miss = p.x < 0 || p.x > 127
      const currentSlice = state.modLevel[p.x | 0]
      const ground = currentSlice && Math.min(currentSlice[1], 127)
      const hit = ground && p.y >= ground
      if(miss || hit) {
        if(!miss && p.y > 0) {
          explode(p, state)
        } else {
          changeTurn(state)
          playPhrase(3)
        }
        state.projectile = false
      }
     }

    function changeTurn(state) {
      state.turn = (state.lastTurn + 1) % state.tanks.length
      state.turnsPlayed++
     }

    function updateTrajectory(state) {
      const p = state.projectile
      if(!p) return
      const trajectory = state.trajectory[state.lastTurn]
      trajectory.push([p.x, p.y])
     }

    function clearTrajectory(state) {
      state.trajectory[state.turn] = []
     }

    function explode(projectile, state) {
      playPhrase(0)
      state.explosion = {
        x: projectile.x,
        y: projectile.y,
        r: 1,
        startTime: state.time
      }
     }

    function updateExplode(state) {
      const e = state.explosion
      if(!e) return false
      e.r++
      
      // destroy ground
      state.modLevel.filter((column, columnX) => {
        const dx = columnX - e.x
        return Math.abs(dx) < e.r
      }).forEach(col => {
        col[1] = Math.min(127, col[1] + e.r / 6)
      });
      
      // damage tanks
      state.tanks.filter(tank => {
        const dx = tank.x - e.x
        const dy = tank.y - e.y
        const d = Math.sqrt(dx*dx + dy*dy)
        return Math.abs(d) < e.r
      }).forEach(tank => {
        tank.h -= 5
        if(tank.h <= 0) state.playing = false
      });
      
      if(e.r > 10) {
        state.explosion = false
        changeTurn(state)
      }
     }

    draw = state => {  
      if(state.firstRunDone) {
        clear(4)
        drawTrajectory(state)
        drawTurnText(state)
        drawTurnIndicator(state)
        drawLand(state)
        state.tanks.forEach(drawTank(state))
        drawProjectile(state)
        drawAimDot(state)
        drawExplosion(state)
        drawWinner(state)
      } else {
        clear(7)
        print(1, 1, 'beta0.6', 6)
        print(58, 122, 'Press A to begin...', 2)
        drawKeysText(state)
        drawIntro(state)
      }
     }

    function drawIntro(state) {
      const offsetX = 20;
      const offsetY = 34 + Math.max(0, 120 - state.introTime / 10);
      introSprites.forEach((letter, letterIndex) => {
        const x = offsetX + letterIndex * 18
        const y = offsetY + Math.round(Math.cos(letterIndex + state.introTime / 300) * 4)
        const v = Math.cos(letterIndex - state.introTime / 500) * 5 - 1
        sprite(x, y, letter[0], Math.round(v))
        sprite(x + 8, y, letter[1], Math.round(v))
        sprite(x, y + 8, letter[2], Math.round(v))
        sprite(x+8, y+8, letter[3], Math.round(v))
      })

      print(31, offsetY - 16, 'cfds games - 2019', 6)
     }

    function drawKeysText(state) {
      const x = 8;
      const y = 80;
      const c = Math.max(Math.min(7, 10 - state.introTime / 400), 4) | 0;
      print(x + 8, y, 'controls:', c)
      print(x + 12, y+10, 'up/down - power', c)
      print(x, y+17, 'left/right - aim', c)
      print(x + 36, y+24, 'A - shoot', c)
     }

    function drawTurnText(state) {
      const survivors = getSurvivors(state)
      if(state.playing && survivors.length > 1 && state.tanks[state.turn]) {
        const turnText = `turn ${
          Math.ceil((state.turnsPlayed + 1) / state.tanks.length)
        }: ${ state.tanks[state.turn].name }`
        print(64 - (turnText.length * 2), 1, turnText, 1)
      }
     }

    function drawTurnIndicator(state) {
      if(state.playing) {
        const tank = state.tanks[state.turn]
        if(!tank) return
        circStroke(tank.x, tank.y, Math.round(tank.p), 3)
        line(tank.x, tank.y, Math.round(tank.u), Math.round(tank.v), 5)
      }
     }

    function drawLand(state) {
      state.modLevel.forEach(point => {
        line(point[0], 128, ...point, 3)
        setPixel(...point, 4)
      })
     }

    function drawAimDot(state) {
      if(state.playing) {
        const tank = state.tanks[state.turn]
        if(!tank) return
        setPixel(Math.round(tank.u), Math.round(tank.v), 1)
      }
     }

    function drawTank(state) {
      return (tank, tankIndex, tanks) => {
        const color = tank.h <= 1 ? 7 : 0
        setPixel(tank.x-1, tank.y, color)
        setPixel(tank.x+1, tank.y, color)
        setPixel(tank.x, tank.y, color)
        setPixel(tank.x, tank.y-1, color)
        const healthOffsetY = tank.y < 120 ? 5 : -5
        if(state.modLevel[tank.x | 0][1] < tank.y + healthOffsetY * 2) {
        rectFill(tank.x - 6, tank.y + healthOffsetY - 1, 13, 3, 4)
        rectFill(tank.x - 5, tank.y + healthOffsetY, Math.ceil(tank.h / 100 * 11), 1, 2)
          print(tank.x - 1, tank.y + healthOffsetY * 2, tank.name[0], tankIndex === state.turn ? 1 : 4)
        }
      }
     }

    function drawTrajectory(state) {
      if(state.survivors.length <= 1) return;
      const turn = state.turn >= 0 ? state.turn : state.lastTurn
      const currentTrajectory = state.trajectory[turn]
      if(!currentTrajectory.length) return
      currentTrajectory.forEach((point, i) => {
        setPixel(...point, 5)
      })
     }

    function drawProjectile(state) {
      if(!state.projectile) return
      const p = state.projectile
      setPixel(p.x, p.y, 1)
     }

    function drawExplosion(state) {
      const e = state.explosion
      if(!e) return
      circFill(e.x, e.y, e.r, Math.max(0, 10 - (e.r / 2 | 0)))
      circStroke(e.x, e.y, e.r+e.r, 3)
     }

    function drawWinner(state) {
      if(state.survivors.length <= 1) {
        const winner = state.survivors[0].name
        const winnerText = `${winner} wins in ${ Math.ceil((state.turnsPlayed + 1) / state.tanks.length)} turns!`;
        print(64 - (winnerText.length * 1.85), 40, winnerText, 0)
        print(23, 52, 'Press (A) for new game', 3)

        // play jingle
        if(!state.winner) {
          state.winner = true
          playPhrase(1)
        }
      }
     }

    function getSurvivors(state) {
      return state.tanks.filter(t => t.h > 0)
     }
    domingo, 9 de agosto de 2020 19:26

Respuestas

  • Hola Danielovis:

    Creo que no es el camino más apropiado el que has escogido para solicitar ayuda. A lo mejor me confundo bastante (en realidad, eso es seguro), pero te cuento las cosas tal cuál las veo yo.

    Este es un sitio donde profesionales/estudiantes de TI comparten información/formación sobre tecnologías vinculadas a Microsoft. 

    Creo que soltar un código de tropecientas lineas, que ha escrito alguien desconocido, sin  contar nada, ni tan siquiera pegar partes que hayas intentado tú, o comentarios de donde se extraiga información para saber que estás con esta parte has podido, pero con esta que se te atraganta o no puedes con ella, porque todavía no tienes la formación adecuada, para x cosa en x lenguaje, no va a ser el camino donde consigas resultados que te ayuden.

    Intenta esclarecer un escenario, donde cuentes lo que tienes y el objetivo, y luego lo que necesitas, y es posible, que alguien te indique algo más.

    Suerte


    • Marcado como respuesta EricRRModerator miércoles, 19 de agosto de 2020 15:53
    lunes, 10 de agosto de 2020 5:57

Todas las respuestas

  • Hola Danielovis:

    Creo que no es el camino más apropiado el que has escogido para solicitar ayuda. A lo mejor me confundo bastante (en realidad, eso es seguro), pero te cuento las cosas tal cuál las veo yo.

    Este es un sitio donde profesionales/estudiantes de TI comparten información/formación sobre tecnologías vinculadas a Microsoft. 

    Creo que soltar un código de tropecientas lineas, que ha escrito alguien desconocido, sin  contar nada, ni tan siquiera pegar partes que hayas intentado tú, o comentarios de donde se extraiga información para saber que estás con esta parte has podido, pero con esta que se te atraganta o no puedes con ella, porque todavía no tienes la formación adecuada, para x cosa en x lenguaje, no va a ser el camino donde consigas resultados que te ayuden.

    Intenta esclarecer un escenario, donde cuentes lo que tienes y el objetivo, y luego lo que necesitas, y es posible, que alguien te indique algo más.

    Suerte


    • Marcado como respuesta EricRRModerator miércoles, 19 de agosto de 2020 15:53
    lunes, 10 de agosto de 2020 5:57
  • Hola Danielovis, 

      

    ¿Alguna novedad sobre la consulta realizada? ¿Han sido útiles las  respuestas proporcionadas?  

    Espero su respuesta.  

    Cualquier duda referente a productos Microsoft, puedes consultarnos. Es un gusto informarte. 

    Gracias por usar los foros de MSDN.  

    Eric Ruiz 

    ____________________________  

     

    Por favor recuerde "Marcar como respuesta" las respuestas que hayan resuelto su problema, es una forma común de reconocer a aquellos que han ayudado, y hace que sea más fácil para los otros visitantes encontrar la solución más tarde.  

    Microsoft ofrece este servicio de forma gratuita, con la finalidad de ayudar a los usuarios y la ampliación de la base de datos de conocimientos relacionados con los productos y tecnologías de Microsoft.   

    Este contenido es proporcionado "tal cual" y no implica ninguna responsabilidad de parte de Microsoft. 

    lunes, 10 de agosto de 2020 16:03
    Moderador
  • Entendido, gracias.
    miércoles, 12 de agosto de 2020 17:38