[Question]
  [
A standard [Scrabble](https://en.wikipedia.org/wiki/Scrabble) board is a 15×15 grid of spaces to place letter tiles. Most of the spaces are blank but some are double word scores (pink), triple word scores (red), double letter scores (light blue), and triple letter scores (blue). There is usually a star in the very center (which counts as a double word score).
[![Scrabble board](https://i.stack.imgur.com/0kZO8m.jpg)](https://i.stack.imgur.com/0kZO8.jpg)
Write a program or function that outputs a standard, empty Scrabble board in ASCII form where:
* `.` represents an empty space
* `D` represents a double word score
* `T` represents a triple word score
* `d` represents a double letter score
* `t` represents a triple letter score
* `X` represents the center star
That is, your exact output must be
```
T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T
```
optionally followed by a trailing newline.
**The shortest code in bytes wins.**
  
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~59~~ ~~54~~ 52 bytes
```
4t:g2I5vXdK8(3K23h32h(H14(t!XR+8: 7:Pht3$)'DtdTX.'w)
```
[Try it online!](http://matl.tryitonline.net/#code=NHQ6ZzJJNXZYZEs4KDNLMjNoMzJoKEgxNCh0IVhSKzg6IDc6UGh0MyQpJ0R0ZFRYLid3KQ&input=)
## Explanation
The code follows three main steps:
1. Generate the 8x8 matrix
```
4 0 0 3 0 0 0 4
0 1 0 0 0 2 0 0
0 0 1 0 0 0 3 0
3 0 0 1 0 0 0 3
0 0 0 0 1 0 0 0
0 2 0 0 0 2 0 0
0 0 3 0 0 0 3 0
4 0 0 3 0 0 0 5
```
2. Extend it to the 15x15 matrix
```
4 0 0 3 0 0 0 4 0 0 0 3 0 0 4
0 1 0 0 0 2 0 0 0 2 0 0 0 1 0
0 0 1 0 0 0 3 0 3 0 0 0 1 0 0
3 0 0 1 0 0 0 3 0 0 0 1 0 0 3
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
0 2 0 0 0 2 0 0 0 2 0 0 0 2 0
0 0 3 0 0 0 3 0 3 0 0 0 3 0 0
4 0 0 3 0 0 0 5 0 0 0 3 0 0 4
0 0 3 0 0 0 3 0 3 0 0 0 3 0 0
0 2 0 0 0 2 0 0 0 2 0 0 0 2 0
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0
3 0 0 1 0 0 0 3 0 0 0 1 0 0 3
0 0 1 0 0 0 3 0 3 0 0 0 1 0 0
0 1 0 0 0 2 0 0 0 2 0 0 0 1 0
4 0 0 3 0 0 0 4 0 0 0 3 0 0 4
```
3. Index the string `'DtdTX.'` with that matrix to produce the desired result.
### Step 1
```
4        % Push 4
t:       % Duplicate, range: pushes [1 2 3 4]
g        % Logical: convert to [1 1 1 1]
2I5      % Push 2, then 3, then 5
v        % Concatenate all stack vertically into vector [4 1 1 1 1 2 3 5]
Xd       % Generate diagonal matrix from that vector
```
Now we need to fill the nonzero off-diagonal entries. We will only fill those below the diagonal, and then make use symmetry to fill the others.
To fill each value we use linear indexing (see [this answer](https://codegolf.stackexchange.com/a/76535/36398), length-12 snippet). That means accessing the matrix as if it had only one dimension. For an 8×8 matrix, each value of the linear index refers to an entry as follows:
```
1   9         57
2  10         58
3  11
4  
5  ...       ...
6  
7             63
8  16 ... ... 64
```
So, the following assigns the value 4 to the lower-left entry:
```
K        % Push 4
8        % Push 8
(        % Assign 4 to the entry with linear index 8
```
The code for the value 3 is similar. In this case the index is a vector, because we need to fill several entries:
```
3        % Push 3
K        % Push 4
23h      % Push 23 and concatenate horizontally: [4 23]
32h      % Push 32 and concatenate horizontally: [4 23 32]
(        % Assign 4 to the entries specified by that vector
```
And for 2:
```
H        % Push 2
14       % Push 14
(        % Assign 2 to that entry
```
We now have the matrix
```
4 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0
3 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0
0 2 0 0 0 2 0 0
0 0 3 0 0 0 3 0
4 0 0 3 0 0 0 5
```
To fill the upper half we exploit symmetry:
```
t!       % Duplicate and transpose
XR       % Keep the upper triangular part without the diagonal
+        % Add element-wise
```
### Step 2
The stack now contains the 8×8 matrix resulting from step 1. To extend this matrix we use indexing, this time in the two dimensions. 
```
8:       % Push vector [1 2 ... 7 8]
7:P      % Push vector [7 6 ... 1]
h        % Concatenate horizontally: [1 2 ... 7 8 7 ... 2 1]. This will be the row index
t        % Duplicate. This will be the column index
3$       % Specify that the next function will take 3 inputs
)        % Index the 8×8 matrix with the two vectors. Gives a 15×15 matrix
```
### Step 3
The stack now contains the 15×15 matrix resulting from step 2.
```
'DtdTX.' % Push this string
w        % Swap the two elements in the stack. This brings the matrix to the top
)        % Index the string with the matrix
```
[Answer]
## JavaScript (ES6), 112 bytes
```
a=Math.abs,f=(n=239)=>n?f(n-1)+(i=a(n%16-8),j=a((n>>4)-7),d=i%7^j%7,n&15?d%4?".":"XdtDDDDTddtd"[(i|j)+d]:`
`):''
```
## JavaScript (ES5), 121 bytes
```
c="";for(a=-8;8>++a;)for(j=0>a?-a:a,b=-8;9>++b;)i=0>b?-b:b,d=i%7^j%7,c+=i-8?d%4?".":"XdtDDDDTddtd"[(i|j)+d]:"\n";alert(c)
```
The ES5 version trades a handwritten `Math.abs()`, two `for` loops and the output via `alert` for the unavailable recursive concise arrow function.
Both versions use the idea in the Ruby/C answer above, by Level River St. Using binary `|` instead of `+` shortens the defining string, `d` stays positive when diffing by `^` instead of `-`.
[Answer]
# Ruby, ~~103~~ 97 bytes
Thanks to Mitch Schwartz for a 6 byte improvement on the iterations.
```
a=(-7..7).map &:abs
a.map{|i|puts a.map{|j|(d=i%7-j%7)%4<1?'X d t DTDdDdDtT d'[i+j+d*d/3]:?.}*''}
```
A similar but significantly different approach to my original answer below. As before, we use the fact that a letter must be printed if `i%7-j%7` is equal to 0 or 4. But here we store that difference in `d` and use the formula `i+j+d*d/3` to give an integer which is unique (up to symmetry) to that particular coloured square. Then we just look it up in the magic string. 
*Just for fun: **C version of this approach, 120 bytes***
```
z,i,j,d;f(){for(z=240;z--;)i=abs(z%16-8),j=abs(z/16-7),putchar(i-8?(d=i%7-j%7)%4?46:"X d t DTDdDdDtT d"[i+j+d*d/3]:10);}
```
# Ruby, ~~115~~ 113 bytes
2 bytes saved thanks to Value Ink.
```
(k=-7..7).map{|y|k.map{|x|i=x.abs;j=y.abs
$><<=(i%7-j%7)%4<1?"#{'XdTdT'[(i+j)/3]}dtDDDD"[[i%7,j%7].min]:?.}
puts}
```
**Explanation**
The origin is considered to be the centre of the board.
A letter must be printed if the x and y coordinates of the square have magnitudes that are identical or differ by 4. The only exceptions are on the outer edge of the board, but these follow the same pattern as the central row/column of the board, so we can use the same condition if we take the x and y coordinates modulo 7. 
The choice of letter displayed is based on the coordinate of minimum magnitude. In this way the doubles and triples at (1,5) and (2,6) follow the same rule as at (1,1) and (2,2) and are obtained from the 7 character string `"#{formula}dtDDDD"` This does not cover all variations for the edge and centreline squares, so the first character of the string is calculated from the formula `'XdTdT'[(i+j)/3]`. 
```
(k=-7..7).map{|y|
  k.map{|x|
    i=x.abs;j=y.abs
    print (i%7-j%7)%4<1?      #IF this expression is true print a letter 
    "#{'XdTdT'[(i+j)/3]       #select 1st character of magic string where [i%7,j%7].min==0 
     }dtDDDD"[[i%7,j%7].min]: #remaining 6 characters of magic string for diagonal
    ?.                        #ELSE print .
  }
  puts                        #at the end of the row print a newline
}
```
[Answer]
# [brainfuck](http://esolangs.org/wiki/Brainfuck), ~~598~~ ~~596~~ 590 bytes
Golfing tips welcome.
```
>-[++++[<]>->+]<[>++++>+++++>+++>++<<<<-]>[>>>>+>+>+<<<<<<-]<++++++++++[>+>>>>+>-<<<<<<-]>>+>->>-->++.<<..>.<...>>.<<...>.<..>>.<<<<<.>>>.<.>...<<.>>...<<.>>...<.>.<<<.>>>..<.>...>.<.>.<...<.>..<<<.>>>>.<..<.>...>.<...<.>..>.<<<<.>>>....<.>.....<.>....<<<.>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.>>>..>.<...>.<.>.<...>.<..<<<.>>>>>.<<..>.<...>>>----.<<<...>.<..>>.<<<<<.>>>..>.<...>.<.>.<...>.<..<<<.>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.>>>....<.>.....<.>....<<<.>>>>.<..<.>...>.<...<.>..>.<<<<.>>>..<.>...>.<.>.<...<.>..<<<.>>>.<.>...<<.>>...<<.>>...<.>.<<<.>>>>>.<<..>.<...>>.<<...>.<..>>.
```
**Explanation**
Initialize the tape to **[10 116 68 46 100 84 92]** i.e. **[nl t D . d T \]**
`>-[++++[<]>->+]<[>++++>+++++>+++>++<<<<-]>[>>>>+>+>+<<<<<<-]<++++++++++[>+>>>>+>-<<<<<<-]>>+>->>-->++`
Each line here then prints one line of the board.  
The middle line also decreases `92 to 88 i.e. \ to X`
```
.<<..>.<...>>.<<...>.<..>>.<<<<<.
>>>.<.>...<<.>>...<<.>>...<.>.<<<.
>>>..<.>...>.<.>.<...<.>..<<<.
>>>>.<..<.>...>.<...<.>..>.<<<<.
>>>....<.>.....<.>....<<<.
>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.
>>>..>.<...>.<.>.<...>.<..<<<.
>>>>>.<<..>.<...>>>----.<<<...>.<..>>.<<<<<.
>>>..>.<...>.<.>.<...>.<..<<<.
>>>.<<.>>...<<.>>...<<.>>...<<.>>.<<<.
>>>....<.>.....<.>....<<<.
>>>>.<..<.>...>.<...<.>..>.<<<<.
>>>..<.>...>.<.>.<...<.>..<<<.
>>>.<.>...<<.>>...<<.>>...<.>.<<<.
>>>>>.<<..>.<...>>.<<...>.<..>>.
```
[Try it online!](http://brainfuck.tryitonline.net/#code=Pi1bKysrK1s8XT4tPitdPFs-KysrKz4rKysrKz4rKys-Kys8PDw8LV0-Wz4-Pj4rPis-Kzw8PDw8PC1dPCsrKysrKysrKytbPis-Pj4-Kz4tPDw8PDw8LV0-Pis-LT4-LS0-KysuPDwuLj4uPC4uLj4-Ljw8Li4uPi48Li4-Pi48PDw8PC4-Pj4uPC4-Li4uPDwuPj4uLi48PC4-Pi4uLjwuPi48PDwuPj4-Li48Lj4uLi4-LjwuPi48Li4uPC4-Li48PDwuPj4-Pi48Li48Lj4uLi4-LjwuLi48Lj4uLj4uPDw8PC4-Pj4uLi4uPC4-Li4uLi48Lj4uLi4uPDw8Lj4-Pi48PC4-Pi4uLjw8Lj4-Li4uPDwuPj4uLi48PC4-Pi48PDwuPj4-Li4-LjwuLi4-LjwuPi48Li4uPi48Li48PDwuPj4-Pj4uPDwuLj4uPC4uLj4-Pi0tLS0uPDw8Li4uPi48Li4-Pi48PDw8PC4-Pj4uLj4uPC4uLj4uPC4-LjwuLi4-LjwuLjw8PC4-Pj4uPDwuPj4uLi48PC4-Pi4uLjw8Lj4-Li4uPDwuPj4uPDw8Lj4-Pi4uLi48Lj4uLi4uLjwuPi4uLi48PDwuPj4-Pi48Li48Lj4uLi4-LjwuLi48Lj4uLj4uPDw8PC4-Pj4uLjwuPi4uLj4uPC4-LjwuLi48Lj4uLjw8PC4-Pj4uPC4-Li4uPDwuPj4uLi48PC4-Pi4uLjwuPi48PDwuPj4-Pj4uPDwuLj4uPC4uLj4-Ljw8Li4uPi48Li4-Pi4&input=)
[Answer]
## PowerShell v2+, ~~147~~ 143 bytes
```
($x='T..d...T...d..T')
($y='.D...t..','..D...d.','d..D...d','....D...','.t...t..','..d...d.'|%{$_+-join$_[6..0]})
'T..d...X...d..T'
$y[5..0]
$x
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0OlwlY9RE8vRU9PD0iB6BB1TS4NlUpbdT0XoECJnp66jroemJ0CYqZA2WBRCBvELEFSmwJRW6NarRKvrZuVn5mnEh9tpqdnEFuryQWzLQJmG5dKZbQpSJJLpeL/fwA "PowerShell – Try It Online")
Takes advantage of how the default `Write-Output` at end of program execution handles arrays (i.e., it inserts a newline between elements). Might be a better way to generate the middle of the board -- I'm still working at it.
The first line outputs the top line of the board, also storing it in `$x` for use later.
The next line generates all the Double-Word lines by taking the left "half" of each, mirroring them (the `-join$_[6..0]` statement), and storing them as elements in array `$y`.
The next line is the middle row, with an `X` in the middle, thanks to `-replace`.
The next line outputs `$y` in reverse order, giving us the bottom Double-Word lines.
The final line is just `$x` again.
```
PS C:\Tools\Scripts\golfing> .\draw-empty-scrabble-board.ps1
T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T
```
*-4 bytes thanks to Veskah.*
[Answer]
# ><> (Fish), 153 Bytes
```
\!o;!?l
\'T..d...T...d..T'a'.D...t...t...D.'a'..D...d.d...D..'a'd..D...d...D..d'a'....D.....D....'a'.t...t...t...t.'a'..d...d.d...d..'a'T..d...'
\'X/'02p
```
A horribly, awfully, inefficient way of doing things. Currently looking into a way of shortening it down by mirroring both horizontally and vertically properly.
[Try it online!](https://fishlanguage.com/playground/TmyT8nk9xFFzDdDhj) (If you don't want to be there all day make sure you either set execution speed to max or run without the animation.)
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~57~~ 53 bytes
### Code
```
•jd]31‚ŽÔc¦Ïïì¹Ep.Üì8Ìa;“•6B4ÝJ".TdDt"‡5'.3×:Â'Xý15ô»
```
Uses the **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=4oCiamRdMzHigJrFvcOUY8Kmw4_Dr8OswrlFcC7DnMOsOMOMYTvigJzigKI2QjTDnUoiLlRkRHQi4oChNScuM8OXOsOCJ1jDvTE1w7TCuw&input=)
---
### Explanation (outdated)
The `•4ç“–šã&$W§ñçvßÖŠ_æá_VFÛÞýi~7¾¬ÏXôc•5B` decompresses to this number:
```
1002000100020010400030003000400040002020004002004000200040020000400000400000300030003000300020002020002001002000
```
With `4ÝJ".TdtD"‡`, we transliterate the following in this big number:
```
0 -> .
1 -> T
2 -> d
3 -> t
4 -> D
```
We bifurcate the whole string, leaving the string and the string reversed on the stack and join them by `"X"` using `ý`. We split the entire string into pieces of 15 using th `15ô` code and join the whole array by newlines using `»`.
[Answer]
## C, ~~146~~ ~~145~~ ~~142~~ 138 bytes
```
i,r,c;main(){for(;i<240;)r=abs(i/16-7),c="T..12..0..12..0"[r+7-abs(i%16-7)],putchar(++i%16?c&4?c:"Xd.dd.tt.D..D.dD.dD.tTd."[c%4+r*3]:10);}
```
[Try it online!](http://coliru.stacked-crooked.com/a/0c24328d5c32d603 "Try it online!")
*~~1 byte~~5 bytes saved thanks to Level River St*
This exploits the diagonal pattern of the board for encoding. In particular, if we take the top left quadrant of the board and align the diagonal, we get:
```
       T..d...T
      .D...t..
     ..D...d.
    d..D...d
   ....D...
  .t...t..
 ..d...d.
T..d...X
```
...a lot of the columns now line up. If we encode columns in a line this way:
```
       0..12..0 y/012/Td./
      .0..12..  y/012/D.t/
     ..0..12.   y/012/D.d/
    2..0..12    y/012/D.d/
   12..0..1     y/012/D../
  .12..0..      y/012/tt./
 ..12..0.       y/012/dd./
T..12..0        y/012/Xd./
```
...then the board pattern can be collapsed into a 15 character string: `T..12..0..12..0`; and we simply need the right mappings for each row.
With that in mind, here's an expanded version with comments:
```
i,r,c;
main() {
   for(;i<240;)  // one char per output including new line
   r=abs(i/16-7) // row; goes from 7 to 0 and back to 7.
   , c="T..12..0..12..0"[r+7-abs(i%16-7)] // pattern char
   , putchar(++i%16 // if this is 0 we need a new line
   ? c&4 // hash to distinguish 'T' and '.' from '0', '1', '2'
     ? c // print 'T' and '.' literally
     : "Xd.dd.tt.D..D.dD.dD.tTd."[c%4+r*3] // otherwise look up replacement char
   : 10 // print the new line
   );
}
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~49~~ 44 bytes
```
•1nÑ=}íge/Þ9,ÑT‰yo¬iNˆå•6B8ôû€û»5ÝJ".TtdDX"‡
```
[Try it online!](https://tio.run/nexus/05ab1e#AUUAuv//4oCiMW7DkT19w61nZS/Dnjksw5FU4oCweW/CrGlOy4bDpeKAojZCOMO0w7vigqzDu8K7NcOdSiIuVHRkRFgi4oCh//8 "05AB1E – TIO Nexus")
# Explained:
Push: `1003000104000200004000303004000300004000020002000030003010030005`
Split into chunks of 8, palindromize each.
Palindromize again.
Replace numbers with characters.
---
# Other Idea (Someone Try this in MATL)
Seeing as EVERYTHING is garunteed to have a period inbetween it...
Count the number of zeros inbetween each piece:
```
1003000104000200004000303004000300004000020002000030003010030005
^  ^   ^ ^   ^    ^   ^ ^  ^   ^    ^    ^   ^    ^   ^ ^  ^   ^
```
`131424334342233135 => w\F6ß¿`
Taking the counts of zeros runs:
`23134312344343123 => ì:¼˜¾`
Then you would decrypt and transpose them together.
Using them in 05AB1E (results in a +5 byte increase):
# [05AB1E](https://github.com/Adriandmen/05AB1E), 27 bytes
```
•w\F6ß¿•6BS•ì:¼˜¾•5BS0×‚øJJ
```
[Try it...](https://tio.run/nexus/05ab1e#@/@oYVF5jJvZ4fmH9gOZZk7BQPLwGqtDe07PObQPyDZ1CjY4PP1Rw6zDO7y8/v83MjY0NjE2NDI2MYHQAA "05AB1E – TIO Nexus")
---
Meta-golfed entry:
# [05AB1E](https://github.com/Adriandmen/05AB1E), 104 bytes
```
•G¨J´JÏÍ?»"”Ö3úoÙƒ¢y”vf%¯‚6À°IÕNO’Å2Õ=ÙŠxn®žÑŸ¶¼t¨š,Ä]ÓŽÉéÈºÂ/ø‡ŸÖ|e³J—Ë'~!hj«igÄ‹Î‚wî’©•7BžLR"
.DTXdt"‡
```
[Try it!](https://tio.run/nexus/05ab1e#AbAAT///4oCiR8KoSsK0SsOPw40/wrsi4oCdw5Yzw7pvw5nGksKieeKAnXZmJcKv4oCaNsOAwrBJw5VOT@KAmcOFMsOVPcOZxaB4bsKuxb7DkcW4wrbCvHTCqMWhLMOEXcOTxb3DicOpw4jCusOCL8O44oChxbjDlnxlwrNK4oCUw4snfiFoasKraWfDhOKAucOO4oCad8Ou4oCZwqnigKI3QsW@TFIiCi5EVFhkdCLigKH//w "05AB1E – TIO Nexus")
Meta-golfed using my meta-golfer for ASCII art:
<https://tio.run/nexus/05ab1e#JY9NSgNBEIWvUo4/qAQxyfi30yAioiAiuBM6M9U9DT3doao7ccBFrhI3ooss3QguJniRXCR2x01RfK9479Xqtf2@XHy2H78/tw/L6aydq8VXr5sPsuX0LeP1jCwbJD3r54v3dp5mFGbZzWp1wXBPyLpE6@GRQj0C1spiCQJ4gjjSVgG@YBG8HiM4KpHAWbgiXYqmA1wF79ONrxCGa5nBOyCUQSEyCFuCi2LEklwNjGO0YAQpNA3cBTa6hsIF60kjd9Y@jAWhF9SAk1C5Gk1yiTSQ9g1MBKcKAp4q7RGuXWCMFlYioS3iKowBhf@9Kh2DNbEHGSIexhSZeDRIUcq4oTDxDS09aAsjZ3TRHGycb25tP@/s7@51e/386Pjk9OzwDw>
[Answer]
# Python 3, 138 bytes
```
d=lambda s:s+s[-2::-1]
print(*d(list(map(d,'T..d...T .D...t.. ..D...d. d..D...d ....D... .t...t.. ..d...d. T..d...X '.split()))),sep='\n')
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 33 bytes (noncompeting)
All credit for this answer goes to [@DLosc](https://codegolf.stackexchange.com/users/16766/dlosc).
```
T↑↑↘tdd↗→→↖XdtDDDD↓T..d‖Ｏ⟦↗→↓⟧ＵＢ.
```
[Try it online!](https://tio.run/nexus/charcoal#@x/yqG0iGM0oSUl51Db9UdskMJoWkVLiAgSP2iaH6OmlPGqY9n7P@kfzl8GUTH40f/n7PVvf71mk9/8/AA "Charcoal – TIO Nexus")
## Verbose
```
Print("T")
Move(:Up)
Move(:Up)
Print(:DownRight, "tdd")
Move(:UpRight)
Move(:Right)
Move(:Right)
Print(:UpLeft, "XdtDDDD")
Print(:Down, "T..d")
ReflectOverlap([:UpRight, :Right, :Down])
SetBackground(".")
```
[Try it online!](https://tio.run/nexus/charcoal#@x9QlJlXoqEUoqTJ5ZtflqphFVqAzIJIW7nkl@cFZaZnlOgoKJWkpCApBovCuNg4UBNCC3xS00DaI1JKXIBACcVsoHiInh7I3KDUtJzU5BL/stSinMQCjWiYFToKVjAapCFWkys4tcQpMTk7vSi/NC9FQ0lPSfP///@6ZQA "Charcoal – TIO Nexus")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 30 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
TDDDDtdX＼tdd＼６２╋d４１╋T８１╋：⤢ｎ┼.ｒ
```
[Try it here!](https://dzaima.github.io/Canvas/?u=VERERER0ZFgldUZGM0N0ZGQldUZGM0MldUZGMTYldUZGMTIldTI1NEJkJXVGRjE0JXVGRjExJXUyNTRCVCV1RkYxOCV1RkYxMSV1MjU0QiV1RkYxQSV1MjkyMiV1RkY0RSV1MjUzQy4ldUZGNTI_,v=8)
A different enough approach to the existing Canvas answer to justify its own post, I think.
Constructs the art as follows:
```
T
 D
  D
   D
    D
     t
      d
       X
```
  
```
T
 D   t
  D   d
   D   d
    D
     t
      d
       X
```
  
```
T  d
 D   t
  D   d
   D   d
    D
     t
      d
       X
```
  
```
T  d   T
 D   t
  D   d
   D   d
    D
     t
      d
       X
```
  
```
T  d   T
 D   t
  D   d
d  D   d
    D
 t   t
  d   d
T  d   X
```
  
```
T  d   T   d  T
 D   t   t   D 
  D   d d   D  
d  D   d   D  d
    D     D    
 t   t   t   t 
  d   d d   d  
T  d   X   d  T
  d   d d   d  
 t   t   t   t 
    D     D    
d  D   d   D  d
  D   d d   D  
 D   t   t   D 
T  d   T   d  T
```
  
```
T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T
```
[Answer]
## Javascript (ES6), 150 bytes
```
_=>(r='',"T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3".replace(/./g,c=>(c=+c?'.'.repeat(c):c,r=c+r,c))+'X'+r).match(/.{15}/g).join`
`
```
### How it works
The string `"T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3"` describes the board from its top left corner to the square just before the 'X', with consecutive empty squares encoded as digits. The `replace()` function both unpacks the empty squares and builds the mirror string `r` for the bottom of the board. Then both parts are put together and carriage returns are inserted every 15 characters.
### Demo
```
let f =
_=>(r='',"T2d3T3d2T.D3t3t3D3D3d.d3D2d2D3d3D2d4D5D5t3t3t3t3d3d.d3d2T2d3".replace(/./g,c=>(c=+c?'.'.repeat(c):c,r=c+r,c))+'X'+r).match(/.{15}/g).join`
`
console.log(f())
```
[Answer]
## JavaScript (ES6), 221 bytes
```
f=
_=>(a=[...Array(15)].map(_=>Array(15).fill`.`),r=([c,i,j])=>[a[i][j]=a[k=14-i][j]=a[i][j=14-j]=a[k][j]=c,j,i],[..."TDDDDtdX"].map((c,i)=>r([c,i,i])),"d30t51d62d73T70".replace(/.../g,s=>r(r(s))),a.map(a=>a.join``).join`
`)
;o.textContent=f()
```
```
<pre id=o>
```
Since I went to the trouble of creating this I thought I'd post it anyway even though there's a clearly superior solution available.
[Answer]
## C 234 Bytes
```
#define g(t) while(i++<8)putchar(*b++);b-=2;--i;while(--i>0)putchar(*b--);putchar('\n');b+=t;
char*r="T..d...T.D...t....D...d.d..D...d....D....t...t....d...d.T..d...X";i;f(){char*b=r;do{g(9);}while(*b);b-=16;do{g(-7);}while(b>=r);}
```
Here's the output:
```
T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T
```
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 33 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
“e+╪>ｖ.２eC｝¼Ｐ↕V⁸╋ＵＳF∔uiＴ═Ｉk¼‟８ｎ┼┼
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXUyMDFDZSsldTI1NkElM0UldUZGNTYuJXVGRjEyZUMldUZGNUQlQkMldUZGMzAldTIxOTVWJXUyMDc4JXUyNTRCJXVGRjM1JXVGRjMzRiV1MjIxNHVpJXVGRjM0JXUyNTUwJXVGRjI5ayVCQyV1MjAxRiV1RkYxOCV1RkY0RSV1MjUzQyV1MjUzQw__,v=8)
uses a huge compressed string and quad palidromizes it. Can probably be shortened by adding the main diagonal later.
[Answer]
## Haskell, 114 bytes
```
g=(++)<*>reverse.init
unlines$g$g<$>words"T..d...T .D...t.. ..D...d. d..D...d ....D... .t...t.. ..d...d. T..d...X"
```
`g` in a non-pointfree version is `g x = x ++ (reverse (init x))`. It is applied once per (half-)line and again on the result.
[Answer]
## sh + coreutils, 119 bytes
This is a binary file. Shown as hexdump:
```
00000000  74 61 69 6c 20 2d 63 39  34 20 24 30 7c 67 75 6e  |tail -c94 $0|gun|
00000010  7a 69 70 0a 65 78 69 74  0a 1f 8b 08 00 2e ec ca  |zip.exit........|
00000020  57 00 03 65 4f c9 0d c0  30 08 fb 7b 18 4f 91 11  |W..eO...0..{.O..|
00000030  fc e8 00 1e a1 fb ab 08  68 a4 90 07 60 d9 98 43  |........h...`..C|
00000040  a4 49 8a 59 05 ae 40 6f  c7 22 98 84 b3 29 10 fc  |.I.Y..@o."...)..|
00000050  13 59 1d 7a 11 9d b1 bd  15 a8 56 77 26 54 c4 b3  |.Y.z......Vw&T..|
00000060  f7 0d fd f6 9f f3 ef fd  e7 7d f3 7e 8d ff 3e 05  |.........}.~..>.|
00000070  57 d9 a0 f0 00 00 00                              |W......|
00000077
```
Here's the base64 form so you can copy/paste it:
```
begin-base64 755 test.sh
dGFpbCAtYzk0ICQwfGd1bnppcApleGl0Ch+LCAAu7MpXAANlT8kNwDAI+3sY
T5ER/OgAHqH7qwhopJAHYNmYQ6RJilkFrkBvxyKYhLMpEPwTWR16EZ2xvRWo
VncmVMSz9w399p/z7/3nffN+jf8+BVfZoPAAAAA=
====
```
[Answer]
# C ~~230~~ 228 Bytes
```
char *s="T.D..Dd..D....D.t...t..d...dT..d...X";
int x,y,a,b;
#define X(N) {putchar(s[a]);N y<=x?1:y;}
#define P for(y=1;y<8;y++)X(a+=)for(y--;y+1;y--)X(a-=)puts("");
main(){for(;x<8;x++){a=b+=x;P}for(x=6;x+1;x--){a=b-=(x+1);P}}
```
[try it on ideone](https://ideone.com/Cp3Jfr)
This is an attempt at improving the original C version posted that had quarter of board stored in a C array. Not as short as I was hoping for. This version only has one eighth of the board stored.
Ungolfed:
```
char *s="T.D..Dd..D....D.t...t..d...dT..d...X";
int x,y,a,b;
main(){
    for(x = 0; x < 8; x++){
        a=b+=x;
        for(y = 1; y < 8; y++){
            putchar(s[a]);
            a += y<=x ? 1 : y;
        }
        for(y--; y >= 0; y--){
            putchar(s[a]);
            a -= y<=x ? 1 : y;
        }
        puts("");
    }
    for(x=6; x >= 0; x--){
        a=b-=(x+1);
        for(y = 1; y < 8; y++){
            putchar(s[a]);
            a += y<=x ? 1 : y;
        }
        for(y--; y >= 0; y--){
            putchar(s[a]);
            a-= y<=x ? 1 : y;
        }
        puts("");
    }
}
```
[Answer]
## GNU sed, ~~219~~ 205 bytes
```
s/$/T..d...T...d..T/p;h
s/.*/.D...t...t...D./p;G;h
s/.*/..D...d.d...D../p;G;h
s/.*/d..D...d...D..d/p;G;h
s/.*/....D.....D..../p;G;h
s/.*/.t...t...t...t./p;G;h
s/.*/..d...d.d...d../p;G;h
s/.*\n//;s/T/X/2p;g
```
Taking advantage of the mirror symmetry of the board, the second half is the first one that was stored in reverse order in the hold space.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 40 bytes
```
•7â∍û¯øÉ»₄XÍ«Ÿ=SPтŸƶR±•".TdDtX"Åв8äJ€ûû»
```
[Try it online!](https://tio.run/##AU8AsP9vc2FiaWX//@KAojfDouKIjcO7wq/DuMOJwrvigoRYw43Cq8W4PVNQ0YLFuMa2UsKx4oCiIi5UZER0WCLDhdCyOMOkSuKCrMO7w7vCu/// "05AB1E – Try It Online")
```
•...•".TdDtX"Åв8äJ€ûû»  # trimmed program
                     »  # join...
             Åв         # list of characters of...
     ".TdDtX"           # literal...
             Åв         # with indices in base-10 values of base length of...
     ".TdDtX"           # literal...
             Åв         # digits of...
•...•                   # 10654502656792583423375424705593131734076028132261...
                ä       # split into...
               8        # literal...
                ä       # equal length pieces...
                        # (implicit) with each element...
                 J      # joined...
                  €     # with each element...
                   û    # concatenated with itself reversed excluding the first character...
                    û   # concatenated with itself reversed excluding the first element...
                     »  # by newlines
                        # implicit output
```
[Answer]
# Excel, 115 bytes
```
=LET(j,8-ABS(8-ROW(1:15)),k,TRANSPOSE(j),n,IF(k>j,k,j),MID("T.D..Dd..D....D.t...t..d...dT..d...X",n*(n-3)/2+j+k,1))
```
[Link to Spreadsheet](https://1drv.ms/x/s!AkqhtBc2XEHJnCOGDSxu4eGyuWT_?e=8BgSYx)
[Answer]
# Vyxal, 242 bytes
[Try it online!](http://lyxal.pythonanywhere.com?flags=&code=%60T..d...T...d..T%0A.D...t...t...D.%0A..D...d.d...D..%0Ad..D...d...D..d%0A....D.....D....%0A.t...t...t...t.%0A..d...d.d...d..%0AT..d...X...d..T%0A..d...d.d...d..%0A.t...t...t...t.%0A....D.....D....%0Ad..D...d...D..d%0A..D...d.d...D..%0A.D...t...t...D.%0AT..d...T...d..T%60%2C&inputs=&header=&footer=)
```
`T..d...T...d..T
.D...t...t...D.
..D...d.d...D..
d..D...d...D..d
....D.....D....
.t...t...t...t.
..d...d.d...d..
T..d...X...d..T
..d...d.d...d..
.t...t...t...t.
....D.....D....
d..D...d...D..d
..D...d.d...D..
.D...t...t...D.
T..d...T...d..T`,
```
For answer number 4, we have the empty Scrabble board in its natural habitat.
]