maya怎样入门

Posted 2023-05-13

熟悉面板 可以中文英文对照 熟悉快捷键 熟悉基本命令

一般学习步骤 建模 材质 灯光 动画 特效
快捷键：
a SelectAllMarkingMenu　在当前视图框显所有对象∕选择所有标记菜单
b ModifyUpperRadiusPress　修改笔刷上限半径
c SnapToCurve　捕捉到曲线
d EnterEditMode　进入编辑模式（按下开始，释放结束）
e RotateToolWithSnapMarkingMenu　旋转工具∕捕捉标记菜单
f FrameSelected　在当前视图框显选择对象
g RepeatLast　重复上次操作
h UIModeMarkingMenu　UI模式标记菜单
i InsertKeyToolActivate　插入关键帧工具激活
j MoveRotateScaleToolToggleSnapMode　移动滚动缩放工具捕捉模式切换
k TimeDraggerToolActivate　时间拖曳工具激活
l LockCurveLength　锁定曲线长度
m ModifyDisplacementPress　修改置换
n ModifyPaintValuePress　修改绘画值
o PolyBrushMarkingMenu　多边形笔刷标记菜单
p Parent　建立父物体
q SelectMaskToolMarkingMenu　选择工具∕选择遮罩工具标记菜单
r ScaleToolWithSnapMarkingMenu　缩放工具∕捕捉标记菜单
s SetKey　设置关键帧
t ShowManipulators　显示操纵器
u PaintOperationMarkingMenuPress　绘画操作标记菜单
v SnapToPoint　捕捉到顶点
w TranslateToolWithSnapMarkingMenu　平移工具∕捕捉标记菜单
x SnapToGrid　捕捉到栅格
y NonSacredTool　非专用工具
z Undo　撤消
A FrameAllInAllViews　在所有视图框显所有对象
B ModifyLowerRadiusPress　修改笔刷下限半径
C SnapToCurve　捕捉到曲线
D DuplicateWithTransform　用变换复制
E SetKeyRotate　设置旋转关键帧
F FrameSelectedInAllViews　在所有视图框显选择对象
G RepeatLastActionAtMousePosition　在鼠标位置重复上次操作
H ShowSelectedObjects　显示选择物体
I SelectIsolate　查看选择
J MoveRotateScaleToolToggleSnapRelativeMode移动滚动缩放工具相对捕捉模式切换
M TogglePanelMenubar　面板菜单条切换
P Unparent　解除父物体
Q SelectComponentToolMarkingMenu　选择元素工具标记菜单
R SetKeyScale　设置缩放关键帧
S KeyframeTangentMarkingMenu　关键帧切线标记菜单
V SnapToPoint　捕捉到顶点
W SetKeyTranslate　设置平移关键帧
X SnapToGrid　捕捉到栅格
Z Redo　重做
0 DefaultQualityDisplay　默认画质显示
1 　　 LowQualityDisplay　低画质显示
2 MediumQualityDisplay　中等画质显示
3 HighQualityDisplay　高画质显示
4 DisplayWireframe　显示线框
5 DisplayShaded　显示材质
6 DisplayShadedAndTextured　显示材质和纹理
7 DisplayLight　显示灯光
8 PaintEffectsPanel　绘画效果面板
F1 Help　帮助
F2 ShowAnimationUI　显示动画
F3 ShowModelingUI　显示建模
F4 ShowDynamicsUI　显示动力学
F5 ShowRenderingUI　显示渲染
F6 ToggleMayaLiveControls　活的控制器切换
F8 SelectToggleMode　选择模式切换
F9 SelectVertexMask　选择顶点蒙板
F10 SelectEdgeMask　选择边蒙板
F11 SelectFacetMask　选择面蒙板
F12 SelectUVMask　选择UV蒙板
` SmoothingDisplayToggle　平滑显示切换（适用于平滑代理）
- DecreaseManipulatorSize　减小操纵器大小
= IncreaseManipulatorSize　增加操纵器大小
[ UndoViewChange　撤消视图变换
] RedoViewChange　重做视图变换
' SelectCluster_in_Jasper 选择群集于宝石
, PreviousKey　前一个的关键帧
. NextKey　后一个关键帧
/ PickColorActivate　拾取颜色激活
~ SmoothingDisplayShowBoth　平滑代理两者双显
+ IncreaseManipulatorSize　增加操纵器大小
PreviousViewArrangement　前一视图布局
NextViewArrangement　后一视图布局
< ShrinkPolygonSelectionRegion　收缩多边形选择区域
> GrowPolygonSelectionRegion　扩展多边形选择区域
↑ PickWalkUp　向上拾取
↓ PickWalkDown　向下拾取
← PickWalkLeft　向左拾取
→ PickWalkRight　向右拾取
Page_Up SmoothingLevelIncrease　平滑级别增加
Page_Down SmoothingLevelDecrease　平滑级别减小
Insert EnterEditMode　进入编辑模式（按下开始，再按结束）
Enter CompleteCurrentTool　完成当前工具
Space ShowHotbox　在单一视图和四视图间切换∕显示标记菜单
----------------------------------------------------------------------------------------------
Ctrl a ShowAttributeEditorOrChannelBox　显示属性编辑器或通道框
Ctrl b TemplateBrushSettings　模板笔刷设置
Ctrl c CopySelected　复制
Ctrl d Duplicate　关联复制
Ctrl g Group　成组
Ctrl h HideSelectedObjects　隐藏选择物体
Ctrl i SelectNextIntermediatObject　选择下一个中间对象
Ctrl m ToggleMainMenubar　切换主菜单条
Ctrl n NewScene　新建场景
Ctrl o OpenScene　打开场景
Ctrl q Quit　退出
Ctrl s SaveScene　保存场景
Ctrl v PasteSelected　粘贴
Ctrl w SoftModTool　软修改工具
Ctrl x CutSelected　剪切
Ctrl z Undo　撤消
Ctrl H ShowLastHidden　显示上一次隐藏
Ctrl F9 ConvertSelectionToVertices　转换选择到顶点
Ctrl F10 ConvertSelectionToEdges　转换选择到边
Ctrl F11 ConvertSelectionToFaces　转换选择到面
Ctrl F12 ConvertSelectionToUVs　转换选择到UV
Ctrl ` SmoothProxy　平滑代理
Ctrl ~ SmoothProxyOptions　平滑代理选项
Ctrl ↑ CoarserSubdivLevel　粗糙细分级别
Ctrl ↓ CreateSubdivRegion　创建细分区域
Ctrl Space ToggleUIElements　UI环境切换

Alt a ToggleWireframeInArtisan　在工匠中切换线框方式
Alt b CycleBackgroundColor　循环背景颜色
Alt c ToggleColorFeedback　颜色反馈切换
Alt f FloodSurfaces　覆盖表面
Alt h HideUnselectedObjects　隐藏未选对象
Alt m FullHotboxDisplay　完整标记菜单显示
Alt q SelectPolygonToolMarkingMenu　选择多边形工具标记菜单
Alt r ToggleReflection　折射切换
Alt s CycleIKHandleStickyState　循环IK手柄粘连状态（7.0已改）
Alt v PlaybackToggle　向后播放
Alt A DecrementFluidCenter　从流体中心递减
Alt S IncrementFluidCenter　从流体中心递增
Alt V GoToMinFrame　回到最小帧
Alt F9 SelectVertexFaceMask　选择顶点面蒙板
Alt ` CreateSubdivSurface　创建细分面
Alt , PreviousFrame　前一帧
Alt . NextFrame　后一帧
Alt ~ CreateSubdivSurfaceOptions　创建细分面选项
Alt ↑ PixelMoveUp　逐象素上移
Alt ↓ PixelMoveDown　逐象素下移
Alt ← PixelMoveLeft　逐象素左移
Alt → PixelMoveRight　逐象素左移

file/ new scene 创建文件
open scene 打开文件
save scene 保存文件
save scene as...另存为
optimize scene size 优化文件 配合组合优化命令使用可以适当的优化文件清楚多余垃圾信息，较少文件存储量。
import...导入
expirt all...全部导出
expirr selection...选择导出

工程文件： 有效的管理你的文件
project/new... 新建工程文件夹
edit current... 编辑 调整你工程文档中的选项
set... 设置 设置新的位置
recent files 最近文件

edit编辑/ undo 向上
redo 向下
redo edit curent.. 重复上一步命令
cut 切
copy 复制
paste 粘贴

delete 删除
delete by type / history 删除历史纪录
select tool 选择
lasso select tool 框选命令
paint seletion tool 笔刷选择
select all全选
deselect 取消
invert selection反选
duplicate 复制
duplicate special 复制编辑菜单
duplicate with transform 阵列复制

group 成组
ungroup 解组
parent 关联
unparent 取消关联

modify模式
transformation tools 变形工具（移动旋转缩放工具的集成模块）
reset transformationd 重置变换（把你的物体归回初始坐标状态）
freeze transformationd 冻结坐标（把你移动的物体坐标归0）

make live 约束物体（作用用来约束物体，可产生吸附效果，使你操作的物体被吸附到约束提上面）center pivot 坐标归于物体中心
convert转换/nurbs to polygons （nurbs转换多边形）
match render tessellation (这个选项控制勾选后转换出来的物体的造型和nurbs物体是一样的但是是3角面）
triangles 3角面 quads 4边面
general 自定义设置 count 整体设置 （这两项控制的转换出多边形的先段数）
contorl points （ 转换成来的模型的于nurbs造型一致）。

smooth mesh preview to polygons 光滑模型转换成多边形（也就是物体3号建显示转换成smooth后的效果）
create创建/ polygon primitives 创建多边形
nurbs primitives 创建nurbs物体
lights 创建灯光
camer as 创建摄像机

cv curve tool 创建cv曲线 ep curve tool 创建ep曲线
text 创建文字
display显示/一些对模型和模块的显示命令就在这个整体模块内。
grid 显示棋盘格
heads up display 场景数据信息显示模块
ui elements 场景模块显示模块

hide 隐藏模块
show 显示模块
polygons 多变形的显示模块

window窗口/这里面集成了一些命令的独立模块。
rendering editors渲染编辑模块/ hypershade材质编辑器
settings/preferences设置/参数/ preferences参数 maya的设置参数 hotkey editor热键设置
marking menu editor专家模式命令模块设置
plug-in manager 插件管理器
uv texture editor uv编辑器
mesh网格/combine 结合
separte 分离模型
extract 分离提取
booleans 布尔运算
smooth 圆滑
average vetitices 均化点
transfer attributes 传递 on on comoonent传递uv和模型 comoonent传递uv
paint transfer attributes weights tool （绘制传递属性权重工具）无
clipboard actions (剪贴板）无

cleanup... 检查
4-sided faces 把4便面转换成3角面
faces with more than 4 sides 把大于4边面的面转换成3角面
concave faces 把凹型面转换成3角面
faces with holse 把带有洞的面连线
non-lianar faces 把不在同一平面上的面连线

edges with holes 取出镶嵌面
reduce 精简 无
paint reduce weights toll 笔刷精简 无
triangulate 转换3角面
quadrangulate 转换4边面

fill hole 封口
make hole toll 创建洞
create polygon tool 画线
sculpt geometry tool 笔刷调整物体形体命令

mirror cut 切割镜像 无 mirror geometry 镜像几何物体 无
editmesh编辑网格/
keep faces together 保持面在一起：保持新生的面在一起，在执行exturde、duplicateces、extarct等操作时，
打开和关闭keep faces together,效果完全不同。操作方式：单击，可以切换其打开和关闭。
extrude挤出: divisions 分割：设定每次挤出的面或边被细分的段数。
smoothing angle 挤出面/平滑的角度：设定一个角度数值，当挤出面的时候，面与面的角度大小设定，也就是是否平滑。
offset偏移：挤出的面的大小偏移。
use selected curve for extrusion 使用曲线挤压：建立一条曲线。选择要挤压物体上的一块面在加选曲线执行挤压命令即可。
twist扭曲、taper 渐变

bridge桥接 ： 操作方式：选择需要桥接在一起的两条边，单击执行。
smooth path 平滑路径 生成一个带有弧度的桥接曲面。
smooth path+curve 平滑路径+曲线 生成一个带有弧度加曲线的曲面。

append to polygon tool 附加多边形工具 （在多边形上添加新的多边形）
divisions 附加多边形工具/分段
limit the number of point 限定点数（限定这行次命令几个点结束）

cut faces tool 切面工具 默认情况下是给你的模型任意添加一条切线。
delete cut faces 删除切割面：删除切割线一侧的模型。
extract cut faces 摘出切割面：将模型从切割线处断开并分离。

split polygon tool自由加线 divisions：加先后此条线段上的点数。
number of points 点的数目：设定沿着边平均放置吸附点的数目，默认是1，并被放置在点的中部。
snapping tolerance 吸附。
insent edge loop tool 环绕加线工具
multiple edge loops 多重边环绕加线
number of edge loops 环绕边的数量

offset edge loop tool 偏移环绕边工具
add divisions 增加分段
transform component 转换构成
flip triangle edge 翻转三角形
poke face 披开面
wedge face 楔入面 使用方法先选择面然后选择临近的一条边执行次命令就会出现一个斜面体。
arc angle 角度
divisions 段数

duplicate face 复制面片
detach component 分离工具
merge vertices 合并点
merge to center 合并到中心
collapse 塌陷
merge vertex tool 点合并工具
merge edge tool 合并边工具 delete edge/vertex 清除边/顶点
chamfer vertex 斜切顶点
width 宽度
remove the face after chamfer移除斜切后产生的面

bevel 倒角 width 宽度 segments段数
slide edge tool 滑行线工具 是你的线段在一个线段间距中保持贴付线段的状态下移动线段。
normals:
vertex normals edit tool 顶点法线编辑工具 （调整模型上点的法线方向）

set vertex normals 设置顶点法线
lock normals 冻结法线
unlock normals 解冻法线
average normals 平均法线
set to face 重置法线
reverse 旋转法线
conform 统一法线
soften edge 软边设置
harden eage 硬边设置
set normal angle 自定义设置 参考技术A 你可以先去【绘学霸】网站找“MAYA影视制作”板块的【免费】视频教程-【点击进入】完整入门到精通视频教程列表： www.huixueba.net/web/AppWebClient/AllCourseAndResourcePage?type=1&tagid=307&zdhhr-10y22r-493659593

想要系统的学习可以考虑报一个网络直播课，推荐CGWANG的网络课。老师讲得细，上完还可以回看，还有同类型录播课可以免费学（赠送终身VIP）。

自制能力相对较弱的话，建议还是去好点的培训机构，实力和规模在国内排名前几的大机构，推荐行业龙头：王氏教育。
王氏教育全国直营校区面授课程试听【复制后面链接在浏览器也可打开】： www.huixueba.com.cn/school/3dmodel?type=3&zdhhr-10y22r-493659593

在“MAYA影视制作”领域的培训机构里，【王氏教育】是国内的老大，且没有加盟分校，都是总部直营的连锁校区。跟很多其它同类型大机构不一样的是：王氏教育每个校区都是实体面授，老师是手把手教，而且有专门的班主任从早盯到晚，爆肝式的学习模式，提升会很快，特别适合基础差的学生。

大家可以先把【绘学霸】APP下载到自己手机，方便碎片时间学习——绘学霸APP下载： www.huixueba.com.cn/Scripts/download.html

ReactJs官方入门教程（井字游戏）

参考技术A

Today, we’re going to build an interactive tic-tac-toe game.

If you like, you can check out the final result here: Final Result . Don’t worry if the code doesn’t make sense to you yet, or if it uses an unfamiliar syntax. We will be learning how to build this game step by step throughout this tutorial.

Try playing the game. You can also click on a button in the move list to go “back in time” and see what the board looked like just after that move was made.

Once you get a little familiar with the game, feel free to close that tab, as we’ll start from a simpler template in the next sections.

We’ll assume some familiarity with HTML and JavaScript, but you should be able to follow along even if you haven’t used them before.

If you need a refresher on JavaScript, we recommend reading this guide . Note that we’re also using some features from ES6, a recent version of JavaScript. In this tutorial, we’re using arrow functions , classes , let , and const statements. You can use the Babel REPL to check what ES6 code compiles to.

There are two ways to complete this tutorial: you could either write the code right in the browser, or you could set up a local development environment on your machine. You can choose either option depending on what you feel comfortable with.

This is the quickest way to get started!

First, open this starter code in a new tab. It should display an empty tic-tac-toe field. We will be editing that code during this tutorial.

You can now skip the next section about setting up a local development environment and head straight to the overview .

Alternatively, you can set up a project on your computer.

Note: this is completely optional and not required for this tutorial!

This is more work, but lets you work from the comfort of your editor.

If you want to do it, here are the steps to follow:

Now if you run npm start in the project folder and open http://localhost:3000 in the browser, you should see an empty tic-tac-toe field.

We recommend following these instructions to configure syntax highlighting for your editor.

If you get stuck, check out the community support resources . In particular, Reactiflux chat is a great way to get quick help. If you don’t get a good answer anywhere, please file an issue, and we’ll help you out.

With this out of the way, let’s get started!

React is a declarative, efficient, and flexible JavaScript library for building user interfaces.

React has a few different kinds of components, but we’ll start with React.Component subclasses:

We’ll get to the funny XML-like tags in a second. Your components tell React what you want to render – then React will efficiently update and render just the right components when your data changes.

Here, ShoppingList is a React component class , or React component type . A component takes in parameters, called props , and returns a hierarchy of views to display via the render method.

The render method returns a description of what you want to render, and then React takes that description and renders it to the screen. In particular, render returns a React element , which is a lightweight description of what to render. Most React developers use a special syntax called JSX which makes it easier to write these structures. The <div /> syntax is transformed at build time to React.createElement(\'div\') . The example above is equivalent to:

See full expanded version.

If you’re curious, createElement() is described in more detail in the API reference , but we won’t be using it directly in this tutorial. Instead, we will keep using JSX.

You can put any JavaScript expression within braces inside JSX. Each React element is a real JavaScript object that you can store in a variable or pass around your program.

The ShoppingList component only renders built-in DOM components, but you can compose custom React components just as easily, by writing <ShoppingList /> . Each component is encapsulated so it can operate independently, which allows you to build complex UIs out of simple components.

Start with this example: Starter Code .

It contains the shell of what we’re building today. We’ve provided the styles so you only need to worry about the JavaScript.

In particular, we have three components:

The Square component renders a single <button> , the Board renders 9 squares, and the Game component renders a board with some placeholders that we’ll fill in later. None of the components are interactive at this point.

Just to get our feet wet, let’s try passing some data from the Board component to the Square component.

In Board’s renderSquare method, change the code to pass a value prop to the Square:

Then change Square’s render method to show that value by replacing /* TODO */ with this.props.value :

Before:

[站外图片上传中...(image-d45328-1515587905953)]

After: You should see a number in each square in the rendered output.

[站外图片上传中...(image-c8a682-1515587905953)]

View the current code.

Let’s make the Square component fill in an “X” when you click it. Try changing the button tag returned in the render() function of the Square like this:

If you click on a square now, you should get an alert in your browser.

This uses the new JavaScript arrow function syntax. Note that we’re passing a function as the onClick prop. Doing onClick=alert(\'click\') would alert immediately instead of when the button is clicked.

React components can have state by setting this.state in the constructor, which should be considered private to the component. Let’s store the current value of the square in state, and change it when the square is clicked.

First, add a constructor to the class to initialize the state:

In JavaScript classes , you need to explicitly call super(); when defining the constructor of a subclass.

Now change the Square render method to display the value from the current state, and to toggle it on click:

Now the <button> tag looks like this:

Whenever this.setState is called, an update to the component is scheduled, causing React to merge in the passed state update and rerender the component along with its descendants. When the component rerenders, this.state.value will be \'X\' so you’ll see an X in the grid.

If you click on any square, an X should show up in it.

View the current code.

The React Devtools extension for Chrome and Firefox lets you inspect a React component tree in your browser devtools.

[站外图片上传中...(image-d9c2c3-1515587905953)]

It lets you inspect the props and state of any of the components in your tree.

After installing it, you can right-click any element on the page, click “Inspect” to open the developer tools, and the React tab will appear as the last tab to the right.

However, note there are a few extra steps to get it working with CodePen:

We now have the basic building blocks for a tic-tac-toe game. But right now, the state is encapsulated in each Square component. To make a fully-working game, we now need to check if one player has won the game, and alternate placing X and O in the squares. To check if someone has won, we’ll need to have the value of all 9 squares in one place, rather than split up across the Square components.

You might think that Board should just inquire what the current state of each Square is. Although it is technically possible to do this in React, it is discouraged because it tends to make code difficult to understand, more brittle, and harder to refactor.

Instead, the best solution here is to store this state in the Board component instead of in each Square – and the Board component can tell each Square what to display, like how we made each square display its index earlier.

When you want to aggregate data from multiple children or to have two child components communicate with each other, move the state upwards so that it lives in the parent component. The parent can then pass the state back down to the children via props, so that the child components are always in sync with each other and with the parent.

Pulling state upwards like this is common when refactoring React components, so let’s take this opportunity to try it out. Add a constructor to the Board and set its initial state to contain an array with 9 nulls, corresponding to the 9 squares:

We’ll fill it in later so that a board looks something like

Board’s renderSquare method currently looks like this:

Modify it to pass a value prop to Square.

View the current code.

Now we need to change what happens when a square is clicked. The Board component now stores which squares are filled, which means we need some way for Square to update the state of Board. Since component state is considered private, we can’t update Board’s state directly from Square.

The usual pattern here is pass down a function from Board to Square that gets called when the square is clicked. Change renderSquare in Board again so that it reads:

We split the returned element into multiple lines for readability, and added parentheses around it so that JavaScript doesn’t insert a semicolon after return and break our code.

Now we’re passing down two props from Board to Square: value and onClick . The latter is a function that Square can call. Let’s make the following changes to Square:

After these changes, the whole Square component looks like this:

Now when the square is clicked, it calls the onClick function that was passed by Board. Let’s recap what happens here:

Note that DOM <button> element’s onClick attribute has a special meaning to React, but we could have named Square’s onClick prop or Board’s handleClick method differently. It is, however, conventional in React apps to use on* names for the attributes and handle* for the handler methods.

Try clicking a square – you should get an error because we haven’t defined handleClick yet. Add it to the Board class.

View the current code.

We call .slice() to copy the squares array instead of mutating the existing array. Jump ahead a section to learn why immutability is important.

Now you should be able to click in squares to fill them again, but the state is stored in the Board component instead of in each Square, which lets us continue building the game. Note how whenever Board’s state changes, the Square components rerender automatically.

Square no longer keeps its own state; it receives its value from its parent Board and informs its parent when it’s clicked. We call components like this controlled components .

In the previous code example, we suggest using the .slice() operator to copy the squares array prior to making changes and to prevent mutating the existing array. Let’s talk about what this means and why it is an important concept to learn.

There are generally two ways for changing data. The first method is to mutate the data by directly changing the values of a variable. The second method is to replace the data with a new copy of the object that also includes desired changes.

The end result is the same but by not mutating (or changing the underlying data) directly we now have an added benefit that can help us increase component and overall application performance.

Immutability also makes some complex features much easier to implement. For example, further in this tutorial we will implement time travel between different stages of the game. Avoiding data mutations lets us keep a reference to older versions of the data, and switch between them if we need to.

Determining if a mutated object has changed is complex because changes are made directly to the object. This then requires comparing the current object to a previous copy, traversing the entire object tree, and comparing each variable and value. This process can become increasingly complex.

Determining how an immutable object has changed is considerably easier. If the object being referenced is different from before, then the object has changed. That’s it.

The biggest benefit of immutability in React comes when you build simple pure components . Since immutable data can more easily determine if changes have been made, it also helps to determine when a component requires being re-rendered.

To learn more about shouldComponentUpdate() and how you can build pure components take a look at Optimizing Performance .

We’ve removed the constructor, and in fact, React supports a simpler syntax called functional components for component types like Square that only consist of a render method. Rather than define a class extending React.Component , simply write a function that takes props and returns what should be rendered.

Replace the whole Square class with this function:

You’ll need to change this.props to props both times it appears. Many components in your apps will be able to be written as functional components: these components tend to be easier to write and React will optimize them more in the future.

While we’re cleaning up the code, we also changed onClick=() => props.onClick() to just onClick=props.onClick , as passing the function down is enough for our example. Note that onClick=props.onClick() would not work because it would call props.onClick immediately instead of passing it down.

View the current code.

An obvious defect in our game is that only X can play. Let’s fix that.

Let’s default the first move to be by ‘X’. Modify our starting state in our Board constructor:

Each time we move we shall toggle xIsNext by flipping the boolean value and saving the state. Now update Board’s handleClick function to flip the value of xIsNext :

Now X and O take turns. Next, change the “status” text in Board’s render so that it also displays who is next:

After these changes you should have this Board component:

View the current code.

Let’s show when a game is won. Add this helper function to the end of the file:

You can call it in Board’s render function to check if anyone has won the game and make the status text show “Winner: [X/O]” when someone wins.

Replace the status declaration in Board’s render with this code:

You can now change handleClick in Board to return early and ignore the click if someone has already won the game or if a square is already filled:

Congratulations! You now have a working tic-tac-toe game. And now you know the basics of React. So you’re probably the real winner here.

View the current code.