[Question]
  [
# Task
Given a positive integer `n`, draw the corresponding rocket.
# Examples
From `n = 1` to `4` the rockets are below. For your program's output, the trailing newline after a rocket is optional.
```
  |
 / \
*---*
| o |
| o |
*---*
 /_\
   |
  / \
 /   \
*-----*
| o o |
| o o |
| o o |
| o o |
*-----*
 /___\
    |
   / \
  /   \
 /     \
*-------*
| o o o |
| o o o |
| o o o |
| o o o |
| o o o |
| o o o |
*-------*
 /_____\
     |
    / \
   /   \
  /     \
 /       \
*---------*
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
| o o o o |
*---------*
 /_______\
```
You can check [this reference implementation](https://tio.run/##bZDNCsIwEITveYohXtq0Rat4EXyTglQb7YJsQloPgu9es63/eAlhd@bb2fXXvnW8GobGHtH5@mC7lnzC6UYhYAutFRRm6MlLIYsVaJNwVqbIoG9a3oq1ElFr60bh6AIIxAg1n2zCORY5ilKIbwKJbz66hbeMyILSB7WqvrB711wVOusljxlbxeh5pjAv@TQgShXOxFYMU0Q4bXj83H7EojOR9eGVoT44fzl35Pi19xR3N40u/kQNtr@EuPcgJ@D3Ccp8Ldv7QNwnn0dOhzs) (ungolfed).
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it... And happy golfing!
  
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~131~~ 117 bytes
```
param($n)' '*$n+" |"
$n..1|%{" "*$_+"/$(' '*++$i)\";$x="*-$('-'*++$i)*"}
$x
,("| $('o '*$n)|")*$i
$x
" /$('_'*--$i)\"
```
[Try it online!](https://tio.run/##LcxBCoMwEEbhfU4x/IwkmRil3ZbepCAuhAoaxS4qND371Ei334O3Lu9hez2HaVJd@62fHSdvyQqnAMownJrmkqsPCMJdQMuu5BB49A/ceL9D4mHxb4Kv4d3UDpkOXs6Vz/DCYwmgcuisxHgeVPX6Aw "PowerShell – Try It Online")
Line breaks added for clarity, but they could just as easily be `;` (it's the same byte count either way).
We're basically brute-force building the rocket one line at a time. We start by taking input `$n`, then construct a string of `$n` spaces and the nose antenna. We then loop from `$n` down to `1`, using a triangular number trick with `$i` to get the appropriate number of middle spaces for the nose cone. Including the construction of the joiner into the loop allows us to re-use `++$i` to both create the joiner and increment for our triangular number, saved into `$x` for later use.
We then use array-multiplication with the comma operator to construct the body of the rocket, then `$x` onto the pipeline again for the bottom. Finally we output the engine part with the appropriate `_` in between.
All of those strings are left on the pipeline, and default implicit output gives us newlines for free.
*-14 bytes thanks to VisualMelon.*
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 38 bytes
```
ＮθＰ×θ_←↗¹Ｐθ←²↑*↑⊗θ↘*ＵＯ⊕θ⊗θo ↑Ｐ⊕θ↑↗θ|‖Ｂ
```
[Try it online!](https://tio.run/##XY89D4IwEIZ3fwXpVAwO6gabYSHxK0RmA3hAk9JCvWJM/O8V0Ah1vLvneXNvXqUqlyk3JhKNxqOuM1C0dYPFQXNkjWIC6YXVcKet55ArcYeT7ID6eyiwH84j4idNzMoKPWdtu@2EDILnbOZOH7kk9iKUOuNw68VpH8qH@MZ/@FPGpShpJHIFNQgc@bnbg9Ihv1@Txv7KFm3sv9DUgLyGxBgKDjnuNCKogj@pGxizNauOvwE "Charcoal – Try It Online") Link is to verbose version of code. Works by drawing the left half of the rocket and reflecting it. Explanation:
```
Ｎθ
```
Input the size of the rocket.
```
Ｐ×θ_
```
Print the `_`s at the base of the rocket.
```
←↗¹
```
Move left and print the `/` at the left of the base.
```
Ｐθ←²
```
Print the `-`s on the second layer.
```
↑*↑⊗θ↘*
```
Print the left side of the rocket, and leave the cursor inside the body.
```
ＵＯ⊕θ⊗θo ↑
```
Fill the rocket with `o`s and move the cursor up.
```
Ｐ⊕θ↑
```
Print the top row of `-`s and move the cursor up.
```
↗θ|‖Ｂ
```
Print the nose cone and reflect to complete the rocket.
Alternate solution, also 38 bytes:
```
Ｎθ×θ_↖¹Ｐ←θ²↑*Ｆ⊗θ←⪫|¶… o⊕θＰ←⁺²θ↖*↖θ|‖Ｂ←
```
[Try it online!](https://tio.run/##bY5BC4IwGIbv/Yqx0xZ2yG55yy5GhUTdgtD1icLcdG6B4H9fk0FKdfyej@d9X1ZmismMW5uIxuizqXNQpKXRIlWV0ORa1dCRNkD4gemHbm/NEQodoLVDJ8N11Xju6aSHc8WFLLEDhVSI7KXJOTxdFUXpXD7IShA83AUOUNwzDnEpG4KRdHcimIIahPYi/duectORcFzxu9cP@ILTXDyM7wsUHJjeGa1BFbz3wTSydmNXL/4G "Charcoal – Try It Online") Link is to verbose version of code. Works by drawing the right half of the rocket and reflecting it. Explanation:
```
Ｎθ
```
Input the size of the rocket.
```
×θ_↖¹
```
Print the base of the rocket.
```
Ｐ←θ²↑*
```
Print the second layer.
```
Ｆ⊗θ←⪫|¶… o
```
Print the body of the rocket.
```
⊕θＰ←⁺²θ↖*
```
Print the top of the rocket.
```
↖θ|‖Ｂ←
```
Print the nose cone and reflect to complete the rocket.
[Answer]
# T-SQL, 265 bytes
```
DECLARE @n INT=0,@o varchar(max)=''z:SELECT
@o+=space(@-@n)+'/'+replicate(' ',@n*2)+' \ 
',@n+=1IF @n<@ GOTO z
PRINT space(@)+' |
'+@o+stuff(replicate('*'+replicate('-',@*2+1)+'*
',2),5+2*@,0,replicate('|'+replicate(' o',@)+' |
',2*@))+' /'+replicate('_',@*2-1)+'\'
```
**[Try it online](https://data.stackexchange.com/stackoverflow/query/edit/1199167)**
[Answer]
# [Python 2](https://docs.python.org/2/), ~~165~~ 154 bytes
```
i=input()
m=["*-"+"--"*i+"*"]
print"\n".join([" "*i+" |"]+[" "*(i-x)+"/ "+"  "*x+"\\"for x in range(i)]+m+["|"+" o"*i+" |"]*2*i+m+[" /"+"_"*(i*2-1)+"\\"])
```
[Try it online!](https://tio.run/##PYw5CsMwEEV7n2L4laRBMXFqn8QWIUWWCXhkhAMK@O6K5CLdX9/63V5Rh1JkFF0/m7HdMk5wHgzv4YThELo1iW6YFad3FDUT6KhoR@DDGPHZMnqqP6o@M@YZj5gokyilmz7vRmzgpe73Nop/ghuqajn1tbg2mBv82R6IYEu5/AA "Python 2 – Try It Online")
*-11 with thanks to @wilkben for some great hints*
Nothing very exciting here. Just builds each line in a list and then prints with `'\n'.join()`. 
[Answer]
# IBM/Lotus Notes Formula Language, ~~262~~ ~~246~~ 236 bytes
```
L:=@NewLine;M:="*"+@Repeat("-";i*2+1)+"*"+L;N:=@Repeat(" ";i+1)+"|"+L;
@For(x:=0;x<i;x:=x+1;@Set("N";N+@Repeat(" ";i-x)+"/"+@Repeat(" ";x*2+1)+"\\"+L));
@Set("N";N+M+@Repeat("|"+@Repeat(" o";i)+" |"+L;2*i)+M+" /"+@Repeat("_";i*2-1)+"\\");
```
Basically a port of my Python 2 answer. Newlines in the code added for readability. They are not required by the interpreter. The formula takes it's input from `i` which is a numeric field on the same form.
There is no online interpreter for Notes formula so here is a screen shot of the output from 1 to 4:
[![enter image description here](https://i.stack.imgur.com/SDSPg.png)](https://i.stack.imgur.com/SDSPg.png)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~52~~ ~~50~~ ~~47~~ ~~45~~ 43 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
'|'/ILúí`©„ oI>∍'|ìI·иI>'-×'*ì.ø`®ð'_:».º.c
```
-2 bytes thanks to *@Grimmy*.
[Try it online](https://tio.run/##AUcAuP9vc2FiaWX//yd8Jy9JTMO6w61gwqnigJ4gb0k@4oiNJ3zDrEnCt9C4ST4nLcOXJyrDrC7DuGDCrsOwJ186wrsuwrouY///NA) or [verify some more test cases](https://tio.run/##AUwAs/9vc2FiaWX/NUX/J3wnL05Mw7rDrWDCqeKAniBvTj7iiI0nfMOsTsK30LhOPictw5cnKsOsLsO4YMKuw7AnXzrCuy7Cui5j/yzCtj//).
**Explanation:**
```
'|           '# Push a "|"
  IL          # Push a list in the range [1,input]
'/  ú        '# Push a "/" with that many leading spaces
     í        # And reverse each string so the spaces become trailing
      `       # And push all strings in this list to the stack
       ©      # Store the last one in variable `®` (without popping)
„ o           # Push string "o "
   I>         # Push the input+1
     ∍        # Extend the string to that size
      '|ì    '# And prepend a "|"
         I·   # Push the input doubled
           и  # And repeat the string that many times as list
I>            # Push the input+1 again
  '-×        '# And create a string with that many "-"
     '*ì     '# And prepend a "*"
        .ø    # Then surround the earlier created list with this string
          `   # And push all separated to the stack
®             # Push the string from variable `®` again
 ð'_:        '# And replace all its spaces with "_"
»             # Now join every string on the stack by newlines
 .º           # Mirror it intersected horizontally
   .c         # And centralize each line (which adds leading spaces where necessary)
              # (after which the result is output implicitly)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 130 bytes
```
->n{["%#{n+2}s"%?|,*(1..n).map{|x|"%#{n-x+2}s%#{x*2}s"%[?/,?\\]},k="*-"+"--"*n+?*,[[?|,*[?o]*n,?|]*" "]*n*2,k," /#{?_*n+=n-1}\\"]}
```
[Try it online!](https://tio.run/##VYxBDoIwEEX3nKIZQqLTKQTUJc5B2sbogg2xEpEE0/bsFYgbdu/lv/z39Pimrk3q6ryGIvdONnGEggPhoS5Ldyyf98GHOWyjmtd5oRm3THNFbIyN1LeACiQoBegkI2m9fmh@WXTEwSIIWBAb6glElXu@LWHrVB2NARvTMH1G0enaZitlf232etrrea8Xm34 "Ruby – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 248 bytes
```
i;f(n){char d[i=2*n+4],o[i];d[i]=o[--i]=!memset(d,45,i);o[--i]=*o='|';*d=d[i]=42;for(i=1+n;i;)printf(--i-n?"%*s/%2$*s\\\n":"%*s|\n",i,"",~i-2*~n-i);for(puts(d);i<=4*n;)i++<=2*n?o[i]="o "[i&1]:puts(o);printf("%s\n /%.*s\\",d,--n,memset(o,95,n+=n));}
```
This is surprisingly hard to get right, especially with off-by-one errors. I still might be overflowing the stack...
I fixed the bug I mentioned with `n=23` and onwards; turns out that `i` was being decremented in the wrong place, so `o` was being overwritten and one byte of it was left uninitialized. Luckily, fixing this didn't cost me anything.
I've added a testcase for `n=50` and a fun one for `n=0`.
*-11 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!*
[Try it online!](https://tio.run/##bY7NboMwEITveQrXKo1t7CZQODQbKw8CHCIc2j2wjoD2kp9XpwZxqtjL7n4azUxtvup6HBEaQfJWf5875gq0qaI4q7QvsILwV9YXxoT10l7a/jIIp7Nco4QFK2@39y0oZ2dxlkLjO4E2iQkQ5LVDGhoRpIZOPFL9LkpfVV@WJfHD9N/DoVFzrp9oUvUkE7wni@vP0AsnAY82UwQS4/g4lTtNzSz3jBf4llSHWeclLEk86ktiu@h9CuHaaWNIL9W9/sw1xZakhMcY5Kw9I4lfj05ubhsWphF7CWz25KGZhIUmqzRdpR@rNFul@f@4x/gH "C (gcc) – Try It Online")
Also, here's your rocket at `n=0`:
```
 |
*-*
*-*
 /| |\
```
Looks more like space junk to me... Ungolfed and an explanation (plus this weird corner case):
```
int i;
void f(int n)
{
    char d[i=2*n+4], // holds the *---* line; 2*n+1 dashes plus an extra 3 for the asterisks and the null byte
         o[i];       // holds the | o | line; 2*n+1 for the 'o ' and extra 3 for pipes and null byte
    d[i]=o[--i]=!memset(d,45,i); // null-terminate d and o; set d to dashes starting at d + 1 and ending at d+i-2
    o[--i]=*o='|'; // set the first and last bytes of o to the pipe
    *d=d[i]=42; // set the first and last bytes of d to asterisks
    for(i=1+n;i;) // print top of rocket
        printf(--i-n?"%*s/%2$*s\\\n":"%*s|\n",i,"",~i-2*~n-i); // on first iteration, print the tip and the correct number of spaces; the * before s pads the empty string with a variable number of spaces
// after that, print the cone; use 2$*s to use the second argument to save a byte
// if anyone can figure out how to remove the need for newlines, that would be appreciated
        // print the dashed line
    for(puts(d);i<=4*n;) // generate and print the tube
        i++<=2*n? // first half of loop
          o[i]="o "[i&1] // generate ' o '
          :puts(o); // print the line
    // n+=n here doubles n for the correct number of underscores
    printf("%s\n /%.*s\\",d,--n,memset(o,95,n+=n)); // print the last dashed line and then generate the underscores and print in one go
    // it's shorter doing a sized print than null-terminating o
}
```
And for the explanation of the corner case: the leading and terminating `|` are set as well as one character (the ) but never printed because there is only one iteration (as `0 <= 0` and `0 <= 2 * 0`). Because `n` is `0`, `d` is not set by `memset`, and is printed as `| |`. The rest should be pretty self-explanatory; the middle is not printed because the loop terminates before it can begin and neither is the cone for pretty much the same reason. There's only one `-` in `*-*` because `n` is `0` (in `2n+1`).
[Answer]
# Batch, ~~700~~ ~~614~~ ~~573~~ ~~538~~ ~~498~~ 452 bytes
Notes:
* **Must be started from `cmd.exe`'s command line using:** `Echo(rockets n|cmd /V:On`, where `n` is an integer.
* Program builds the Nth rocket on a line by line basis, incrementing the values used to repeat characters using the N value
* If the file is run without a parameter, it will output rocket n 1 by default.
* lines `1` and `7` have trailing spaces
**filename**: `rockets.bat`
```
@ECHO OFF&Set $=Set 
!$!}=ECHO(&!$!F=For /L %%A in (1,1,&!$!D=)Do &!$!P=^|&!$!/A _=]=W=1,H=O=2,L=3
%F:1,1=2,1%,%1%D%!$!/A W+=1,O+=1,H+=2,_+=2,L+=2
!$!.=!P!&!$![=!W!&%F%!O!%D%!$!.= !.!
%}%!.!&%F%!W!%D%(!$!.=/
%F:A=B%![!%D%!$!.= !.!
%F:A=C%!]!%D%!$!.=!.! 
!$!.=!.!\&%}%!.!&!$!/A [-=1,]+=2)
!$!*=*&%F%!L!%D%!$!*=!*!-
!$!*=!*!*&%}%!*!&!$!.=!P! 
%F%!W!%D%!$!.=!.!o 
!$!.=!.!!P!&%F%!H!%D%%}%!.!
%}%!*!&!$!.= /&%F%!_!%D%!$!.=!.!_
!$!.=!.!\&%}%!.!
```
[The ungolfed version [1131 bytes]](https://pastebin.com/bp6EBEuy)
[Answer]
# [Wren](https://github.com/munificent/wren), 156 bytes
I am very surprised that Arnauld is so easy to outgolf ...
```
Fn.new{|n|" "*(n+1)+"|
"+(n..1).map{|i|" "*i+"/%(" "*(1+2*(n-i)))\\
"}.join()+"*%("-"*(1+2*n))*
"+"| %("o "*n)|
"*2*n+"*%("-"*(1+2*n))*
 /%("_"*(2*n-1))\\"}
```
[Try it online!](https://tio.run/##bY5BCsIwEEX3PUUYEDIJHYm4desF3BaklCyi7VRiMUjTs8dpdely/n//MSl6Lq82qjh2dz@pkypnJvZpzpxBgdFsHVrIFVjNRA5paB9zDlsZLOx3esOcPQhbB0RsmgoWuo2BtSyNAPUPYEQjIshKwlFmjCI2Uvzh1Kq@SiJ37VYtLOXyfk5@oBTD5PX3Z@ravtdHxPIB "Wren – Try It Online")
[Answer]
# JavaScript (ES6), ~~158~~ 156 bytes
This implements the straightforward *repeat everything* approach.
```
n=>` `[N=n*2,R='repeat'](n+1)+`|
${(g=k=>k?` `[R](k)+`/${' '[R](N-k---k)}\\
`+g(k):s=`*${'-'[R](N+1)}*
`)(n)+`|${' o'[R](n)} |
`[R](N)+s} /${'_'[R](N-1)}\\`
```
[Try it online!](https://tio.run/##ZYyxDoIwFEX3fkUHE/qo1YBOJsU/YGAVYgkWoiUtAeICfHtt0cUwvnPuO6/yXQ5V/@xGps1D2ppbzROBxS3lOoz3GQ962clyDAqiaQRUzGg3kYYrnqir32UFUQ4fd1OAA3@lTDHGFCx5jgRtnL0MXITOs693mSVEAoj2Of9nVqFhwTNaiynQYcG@ef81I98TtjJ6MK08tKYhNYkA0D@JN@S0IWcA@wE "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), ~~164~~ 162 bytes
This one builds the rocket recursively.
```
f=(n,x=y=0,w=2*++n)=>y<w+n?`/\\ |*-o
`[(x>w?x=~!++y:(y?y-n&&~y+3*n?y>n?x&1?2:x%w?6:3:x+y-n&&x-y-n&&2:x%w?5:4:x-n?2:3)||x>n)&7]+f(n,x+1,w):` /${'_'.repeat(w-3)}\\`
```
[Try it online!](https://tio.run/##Zc3disIwEAXge5/CBa2ZTqO28QeCaR5ku9iirewiE1ExE6y@enXdq8WrA985cH6qS3XaHL8PZ0luW3ddYwQlbIKZJt5kMSKBycPKI9lyUhT9NpauV34Kzr1lc/9ADFoEGyRF0T2gismGnCxHqc00D71daKUZXz3LV/z5XM80S3quFLQt5wTR8gub33dMEw@67E8G19F6ND7Wh7o6Cy8V3Iqi7DaOTm5fj/duJxqRAvT@S/Ym6k1mAN0D "JavaScript (Node.js) – Try It Online")
### Commented
```
f = (                            // f is a recursive function taking:
  n,                             //   n = size of the rocket
  x = y = 0,                     //   (x, y) = current coordinates
  w = 2 * ++n                    //   w = width of the rocket - 1; increment n
) =>                             //
  y < w + n ?                    // if this is not the last row:
    `/\\ |*-o\n`[                //   pick the next character from this string
      ( x > w ?                  //     if this is the end of the row:
          x = ~!++y              //       increment y and set x to -1
        :                        //     else:
          ( y ?                  //       if this is not the first row:
              y - n &&           //         if this is neither the top
              ~y + 3 * n ?       //         nor the bottom of the tank:
                y > n ?          //           if this is not the fairing:
                  x & 1 ?        //             if x is odd:
                    2            //               append a space
                  :              //             else:
                    x % w ? 6    //               append either a 'o'
                          : 3    //               or a '|' on the borders
                :                //           else (fairing):
                  x + y - n &&   //             append a '/' if we're located on
                  x - y - n && 2 //             a border, or a space otherwise
              :                  //         else (top or bottom of the tank):
                x % w ? 5        //           append either a '-'
                      : 4        //           or a '*' on the borders
            :                    //       else (first row):
              x - n ? 2          //         append either a space
                    : 3          //         or a '|' in the middle
          )                      //
          || x > n               //       turn '/' into '\' if we're in the right side
      ) & 7                      //     turn -1 into 7, false into 0, true into 1
    ] + f(n, x + 1, w)           //   end of character lookup; recursive call with x+1
  :                              // else:
    ` /${'_'.repeat(w - 3)}\\`   //   append the nozzle and stop the recursion
```
[Answer]
# [Python 2](https://docs.python.org/2/), 126 bytes
```
p=n=input()
s="_ |"+"  \/"*n+"--**"+" o||"*2*n+"--**__\/"
while s:p+=s>"^";print' '*p+s[3]+s[:2]*(n-p)+s[:4:2];s=s[4:];p-=p>0
```
[Try it online!](https://tio.run/##NYlBCsMgEEX3OYXMJokiLSYrZXKR1LoqRChm6BhKQejRrVl08/jvP/rkbU@mVsKEMdGRh7FjhG8QBRQIcbuATAq0lvL0vRSQ5v@E0HL33uLzIdiSQl7gDo5eMeVe9JIUr5NvsMbLIWkazz03c4y8ztY70kjLtdbpBw "Python 2 – Try It Online")
Includes some trailing whitespace, which I hope is allowed. One of them is the first character of `s`, a `DEL` character.
The main idea is to store the design of each line of the rocket in a big template string `s`. It's a bit easier to see in this slightly less golfed version, where the template for each line is given in a list:
**134 bytes**
```
n=input()
p=n+2
w="*--*"
for a,b,c,d in["|   "]+["/  \\"]*n+[w]+["| o|"]*2*n+[w,"/__\\"]:p-=p>0;p+=c=="_";print' '*p+a+(b+c)*(n-p)+b+d
```
[Try it online!](https://tio.run/##HclNCoMwEEDhfU4xzEaTSbCku8r0IiriD6VuJoMoUvDuae3ye08/2ztJzFl4Ed230hploWgORheCQ/NKKwx@9JOfYZEGTwDAjhqsANoWOyfUHJdPSOeP8R88Vn1/7YcG1uetVuKJGXusdV1kK6BwSgOVI03WlRLU0khzzvcv "Python 2 – Try It Online")
Each line of the rocket is drawn from a template like this with four characters `a,b,c,d` specified for each line:
```
  abcbcbcbcbd
```
It's an `a` followed by alternating `b`'s and `c`'s followed by a `d`. The number of leading spaces, which also governs the number of repetitions of `bc`, is given by `p`, and is updated with each new line.
I'm aware that Python 3's f-strings and walrus operator could probably shorten many things, but I like Python 2 for golfing ASCII art because it means finding hacks to do things like that instead.
[Answer]
# [Perl 5](https://www.perl.org/), 150 +1 (-p) = 151 bytes
```
$x=($n=$_)*2;map{$r.=$"x($n-$_).'/'.$"x(2*$_+1).'\
'}0..$n-1;$s='*'.'-'x$x."-*
";$l='|'.' o'x$n." |
";$_=$"x$n.$"."|
$r$s".$l x$x."$s /".'_'x--$x.'\
'
```
Run with `-p`, provide input to stdin. Started with basically the reference implementation, and just golfed it down, though there might be better ways. 
I could save a byte by leaving off the final newline, but I like it better with it in.
[Try it online!](https://tio.run/##Hc3BCsIwDMbx@56ihA@ilWZu4Gn0TYTiwYNQu7J6KDhf3Zp6/P9Cknzf4qU1VH9A8ghHOy/PW35jEw@qik5ReGTpOVuE06R9HfhzFtHxtKB4tizsuKIKOTvQguh5VzOrYhIye8fQb2qChPYBGwoJovmvoZiRhANX57T7h9bm75pfjzWV5vIP "Perl 5 – Try It Online")
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~292~~ ~~289~~ 257 bytes
Thanks to @mypronounismonicareinstate **-32B**
```
n=>{dynamic r="",t="*",i=n,j;for(;i-->0;)r+=" ";r+=" |\n";for(;++i<n;){for(j=0;j<n+i+2;++j)r+=n-i-j==0?"/":" ";r+=@"\
";}for(;i-->0;)t+="--";t+="-*\n";r+=t;for(;++i<n*2;){r+="|";for(j=0;j++<n;)r+=" o";r+=" |\n";};r+=t+" /";for(;i-->1;)r+="_";return r+"\\";}
```
[Try it online!](https://tio.run/##TZAxa8MwEIXn@leImyyfRZxAl57ldOrUvYuhFNcOJ@gFZGUISX67K8mFetEh3XvvO90wm2Hm5e0iQ8sSajUHz3Lq1GQXsd3t@ypfPzwobwHqYKGCmq3UjqazL4mN6RrSHi0ooFzuvcDaRORWSN/SxdmGXCvIeIjvLjnEsHHWNkfYwcuf/RX6AuixzQ4x1BigXKsUHnVhQ6gOkZHQ95WbUYgJnQc6bwd7ZDeC2sH/D/ar8jMKx3DxojxC30fxQkUUqTIuRrHdk@L2OR6Iunj68BzGd5axnErWmpZf "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 95 bytes
v1.0.2, my goal is to get this sub-60, which I think is actually doable.
```
:i)" ":s*"|"n i,{:j i\-s*"/ "2s*j*"l"n}%"*-""--"i*"*"n+++:q{"| ""o "i*"|"n}2i**q" /""__"i*);"l"
```
This program uses miniscule L instead of backslash since I spent like four hours today trying to find a way for GS to print ONE backslash and couldn't get it to work. It's ridiculous. Temporary patchfix, looks acceptable in TIO.
WANNA SEE A GROSS PROGRAM?
Okay, so this is obviously a disaster, so we're going to need to go through it *very* carefully to see why it works. Let's break this into chunks.
```
:i)" ":s*"|"n                 #Top Needle
i,{:j i\-s*"/ "2s*j*"l"n}%    #Roof
"*-""--"i*"*"n+++:q           #First star-dash line
{"| ""o "i*"|"n}2i**          #Cabin
q                             #Second star-dash line
" /""__"i*);"l"               #Rocket cone
```
So, that's mildly more digestible for my format. Work is slow today, so enjoy this overly arduous explanation.
Before we start this, I'm clarifying one thing. Input is from the header, slotted right into the stack, and our output is let on the stack, printed out when the program finishes.
```
:i)" ":s*"|"n     #Print the top needle
:i                #Set our input to i; we'll call it INDEX.
  )               #Increment the INDEX on the stack by 1 (not the variable)
   " ":s          #Put a space on the stack, and make s remember it. We'll call it SPACE.
        *         #Multiply this space by INPUT+1
         "|"      #Needle!
            n     #Newline
```
So, our stack now looks something like `" ""|""/n"`, which is concatenated all together on output. Every future chunk ends with n characters, and we never back up further in the stack, so we never touch this again.
```
i,{:j i\-s*"/ "2s*j*"l"n}%    #Print the roof
i,                            #Make an array of size INDEX, from 0 to i-1
  {                     }%    #Block notation. On every element in this array, perform this
  {:j                   }%    #Remember our index as J
  {   i\-               }%    #Subtract J from INDEX
  {      s*             }%    #Make that many spaces
  {        "/ "         }%    #Make a slash then a space
  {            2s*j*    }%    #Make 2*j spaces
  {                 "l" }%    #lmao backslash no work
  {                    n}%    #Add a newline
```
Which is for what we're looking, for every line. Done INDEX times, we have our roof!. Next!
```
"*-""--"i*"*"n+++:q   #Print the star-line.
"*-"                  #First two characters.
    "--"              #Next two.
        i*            #We want a number of those double-dashes equal to INDEX.
          "*"         #Last asterisk
             n        #Newline
              +++     #Concatenate that all together. We haven't done this before, but...
                 :q   #We're remembering this entire line in Q, which saves us a TON
```
Next we have the o-cabin. Surprisingly the easiest part of the program.
```
{"| ""o "i*"|"n}2i**   #Build the cabin
                2i*    #Double INDEX
{              }   *   #Perform the block 2*INDEX times
{"| "          }   *   #First two characters
{    "o "      }   *   #You know the drill. Combination of the two prev tactics.
{        i*    }   *   #Make that many windows this row
{          "|" }   *   #East wall
{             n}   *   #Newline, as always.
```
Now comes the trickiest part of the entire program
```
q      #Print the second star line
q      #Print Q, as established above
```
And the bottom of the rocket.
```
" /""__"i*);"l"     #Bottom of the rocket
" /"                #So, how's your day been? Mine's been pretty slow.
    "__"            #Slow enough that I had time to write this whole post.
        i*          #Boss isn't even watching. Maybe I'll do another later.
          );        #Remove the last _, since we've one too many.
            "l"     #lmao backslashes
```
And that's everything! Why don't you check my work by [trying it out online](https://tio.run/##FcsxCoQwEEDRqwwfLJwYhJTZqwgWgsuIxHVjp549xvI/@N9tnfP0t99RQonWIsSsXCSx7oyL2OBr90LIuigr6W5QD95jipKcc3E/uQQ2ea3OdzDVHelhHKu1n3qW8gA "GolfScript – Try It Online")? 78 is the max size you can get before it starts to linebreak on TIO on my monitor, try to find yours!
[Answer]
# Clojure (307 bytes)
Great challenge, because it let me crank up Def Leppard's "Rocket" and Elton John's "Rocket Man" while coding. Always a plus! :-)
Golfed:
```
(defn r[n s](apply str(repeat n s)))(defn b[n](r n \ ))(defn p[s](println s))(defn k[n](let[t(str \*(r(inc (* n 2))\-)\*)](p(str(b(inc n))\|))(doseq[l(range 0 n)](p(str(b(- n l))\/(b(inc(* 2 l)))\\)))(p t)(doseq[l(range 1 (inc(* n 2)))](p(str "| "(r n "o ")\|)))(p t)(p(str " /"(r(inc(* 2(dec n)))\_)\\))))
```
[Try it online!](https://tio.run/##XY/BCsIwEETvfsWS025BtNW/SYq0NYoa0pjGg@C/182mRfCykNl5M5vBjfdXtPOMZ3vxELWHqcUuBPeGKUWMNtguAatEVDy99i1GlgysUtAMhXjzyYmzqI9sdDbphBwFpsKINz8AVgw3RGZLpiIG8xp72XmWPzlgnOxTO4ydv1rYs/7zbRl37NsVhuOa/CZj8o0B0j9ew@KT2jUJ1AeUfESNoKR2oZc17FS5ODfwl@Q6MqdSRJsNPqCmPBuZB5lHmucv "Clojure – Try It Online")
Ungolfed:
```
(defn repeat-str [n s]
  (apply str (repeat n s)))
(defn blanks [n]
   (repeat-str n \ ))
(defn rocket [n]
  (let [ top-bottom  (str \* (repeat-str (inc (* n 2)) \-) \*) ]
    (println (str (blanks (inc n)) \|))
    (doseq [ l  (range 0 n) ]
      (println (str (blanks (- n l)) \/ (blanks (inc (* 2 l))) \\)))
    (println top-bottom)
    (doseq [ l  (range 1 (inc (* n 2))) ]
      (println (str "| " (repeat-str n "o ") "|")))
    (println top-bottom)
    (println (str " /"  (repeat-str (inc (* 2 (dec n))) \_) \\))))
```
[GUITAR..! DRUMS..!](https://www.youtube.com/watch?v=bpcc43NV394)
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 65 bytes
```
›ð*\|+,(⁰nε\/꘍nd›\\꘍+,)×⁰d›-×+:,⁰d(\|‛ o⁰*ð\|+++,),‛ /\_⁰d‹*\\++,
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%E2%80%BA%C3%B0*%5C%7C%2B%2C%28%E2%81%B0n%CE%B5%5C%2F%EA%98%8Dnd%E2%80%BA%5C%5C%EA%98%8D%2B%2C%29%C3%97%E2%81%B0d%E2%80%BA-%C3%97%2B%3A%2C%E2%81%B0d%28%5C%7C%E2%80%9B%20o%E2%81%B0*%C3%B0%5C%7C%2B%2B%2B%2C%29%2C%E2%80%9B%20%2F%5C_%E2%81%B0d%E2%80%B9*%5C%5C%2B%2B%2C&inputs=4&header=&footer=)
Slowly constructs the string bit by bit.
]